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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Reflection.V2.Derived.fst | FStar.Reflection.V2.Derived.head | val head (t: term) : term | val head (t: term) : term | let rec head (t : term) : term =
match inspect_ln t with
| Tv_Match t _ _
| Tv_Let _ _ _ t _
| Tv_Abs _ t
| Tv_Refine _ t
| Tv_App t _
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ -> head t
| Tv_Unknown
| Tv_Uvar _ _
| Tv_Const _
| Tv_Type _
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_UInst _ _
| Tv_Arrow _ _
| Tv_Unsupp -> t | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 226,
"start_col": 0,
"start_line": 207
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V2.Derived
open FStar.Stubs.Reflection.Types
open FStar.Reflection.Const
open FStar.Stubs.Reflection.V2.Builtins
open FStar.Stubs.Reflection.V2.Data
open FStar.Order
open FStar.VConfig
let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} =
match inspect_ln t with
| Tv_AscribedT t' _ _ _
| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv
let compare_bv (v1 v2 : bv) : order =
Order.compare_int (inspect_bv v1).index (inspect_bv v2).index
let compare_namedv (v1 v2 : namedv) : order =
Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq
let shift n s = match s with
| DB i t -> DB (i+n) t
| DT i t -> DT (i+n) t
| UN i t -> UN (i+n) t
| NM x i -> NM x (i+n)
| UD x i -> UD x (i+n)
| NT _ _ -> s
let shift_subst n s = List.Tot.map (shift n) s
let subst1 (n:namedv) (t1:term) (t2:term) : term =
subst_term [NT n t1] t2
(*
* AR: add versions that take attributes as arguments?
*)
let mk_binder (nm : string) (sort : typ) : simple_binder =
let bv : binder_view = {
ppname = seal nm;
qual = Q_Explicit;
attrs = [];
sort = sort;
}
in
inspect_pack_binder bv;
pack_binder bv
let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
}
let push_binding (e:env) (b:binding) : env =
let nv : namedv = pack_namedv {
uniq = b.uniq;
sort = seal b.sort;
ppname = b.ppname;
}
in
push_namedv e nv
let type_of_binder (b : binder) : typ =
(inspect_binder b).sort
val flatten_name : name -> Tot string
let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) =
match inspect_ln_unascribe t with
| Tv_App l r ->
collect_app_ln' (r::args) l
| _ -> (t, args)
val collect_app_ln : term -> term * list argv
let collect_app_ln = collect_app_ln' []
let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) =
match args with
| [] -> t
| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs
// Helper for when all arguments are explicit
let mk_e_app (t : term) (args : list term) : Tot term =
let e t = (t, Q_Explicit) in
mk_app t (List.Tot.Base.map e args)
let u_unk : universe = pack_universe Uv_Unk
let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) =
match bs with
| [] -> cod
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))
let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) =
match bs with
| [b] -> pack_ln (Tv_Arrow b cod)
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))
let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) =
begin match inspect_comp c with
| C_Total t ->
begin match inspect_ln_unascribe t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_ln_bs : typ -> list binder * comp
let collect_arr_ln_bs t =
let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in
(List.Tot.Base.rev bs, c)
val collect_arr_ln : typ -> list typ * comp
let collect_arr_ln t =
let bs, c = collect_arr_ln_bs t in
List.Tot.Base.map type_of_binder bs, c
let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) =
match inspect_ln_unascribe t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs_ln : term -> list binder * term
let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)
let mk_stringlit (s : string) : term =
pack_ln (Tv_Const (C_String s))
let mk_strcat (t1 t2 : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]
let mk_cons (h t : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]
let mk_cons_t (ty h t : term) : term =
mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]
let rec mk_list (ts : list term) : term =
match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t::ts -> mk_cons t (mk_list ts)
let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term =
match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 -> let [x] = ts in x
| n -> begin
let qn = match n with
| 2 -> mktuple2_qn
| 3 -> mktuple3_qn
| 4 -> mktuple4_qn
| 5 -> mktuple5_qn
| 6 -> mktuple6_qn
| 7 -> mktuple7_qn
| 8 -> mktuple8_qn
in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts
end
let destruct_tuple (t : term) : option (list term) =
let head, args = collect_app_ln t in
match inspect_ln head with
| Tv_FVar fv ->
if List.Tot.Base.mem
(inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn;
mktuple6_qn; mktuple7_qn; mktuple8_qn]
then Some (List.Tot.Base.concatMap (fun (t, q) ->
match q with
| Q_Explicit -> [t]
| _ -> []) args)
else None
| _ -> None
let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.Reflection.Const.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V2.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Builtins.inspect_ln",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.match_returns_ascription",
"Prims.list",
"FStar.Stubs.Reflection.V2.Data.branch",
"FStar.Reflection.V2.Derived.head",
"Prims.bool",
"FStar.Stubs.Reflection.V2.Data.simple_binder",
"FStar.Stubs.Reflection.Types.binder",
"FStar.Stubs.Reflection.V2.Data.argv",
"FStar.Stubs.Reflection.Types.comp",
"Prims.nat",
"FStar.Stubs.Reflection.Types.ctx_uvar_and_subst",
"FStar.Stubs.Reflection.V2.Data.vconst",
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.namedv",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Stubs.Reflection.V2.Data.universes"
] | [
"recursion"
] | false | false | false | true | false | let rec head (t: term) : term =
| match inspect_ln t with
| Tv_Match t _ _
| Tv_Let _ _ _ t _
| Tv_Abs _ t
| Tv_Refine _ t
| Tv_App t _
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ -> head t
| Tv_Unknown
| Tv_Uvar _ _
| Tv_Const _
| Tv_Type _
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_UInst _ _
| Tv_Arrow _ _
| Tv_Unsupp -> t | false |
FStar.Reflection.V2.Derived.fst | FStar.Reflection.V2.Derived.mkpair | val mkpair (t1 t2: term) : term | val mkpair (t1 t2: term) : term | let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2] | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 205,
"start_col": 0,
"start_line": 204
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V2.Derived
open FStar.Stubs.Reflection.Types
open FStar.Reflection.Const
open FStar.Stubs.Reflection.V2.Builtins
open FStar.Stubs.Reflection.V2.Data
open FStar.Order
open FStar.VConfig
let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} =
match inspect_ln t with
| Tv_AscribedT t' _ _ _
| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv
let compare_bv (v1 v2 : bv) : order =
Order.compare_int (inspect_bv v1).index (inspect_bv v2).index
let compare_namedv (v1 v2 : namedv) : order =
Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq
let shift n s = match s with
| DB i t -> DB (i+n) t
| DT i t -> DT (i+n) t
| UN i t -> UN (i+n) t
| NM x i -> NM x (i+n)
| UD x i -> UD x (i+n)
| NT _ _ -> s
let shift_subst n s = List.Tot.map (shift n) s
let subst1 (n:namedv) (t1:term) (t2:term) : term =
subst_term [NT n t1] t2
(*
* AR: add versions that take attributes as arguments?
*)
let mk_binder (nm : string) (sort : typ) : simple_binder =
let bv : binder_view = {
ppname = seal nm;
qual = Q_Explicit;
attrs = [];
sort = sort;
}
in
inspect_pack_binder bv;
pack_binder bv
let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
}
let push_binding (e:env) (b:binding) : env =
let nv : namedv = pack_namedv {
uniq = b.uniq;
sort = seal b.sort;
ppname = b.ppname;
}
in
push_namedv e nv
let type_of_binder (b : binder) : typ =
(inspect_binder b).sort
val flatten_name : name -> Tot string
let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) =
match inspect_ln_unascribe t with
| Tv_App l r ->
collect_app_ln' (r::args) l
| _ -> (t, args)
val collect_app_ln : term -> term * list argv
let collect_app_ln = collect_app_ln' []
let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) =
match args with
| [] -> t
| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs
// Helper for when all arguments are explicit
let mk_e_app (t : term) (args : list term) : Tot term =
let e t = (t, Q_Explicit) in
mk_app t (List.Tot.Base.map e args)
let u_unk : universe = pack_universe Uv_Unk
let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) =
match bs with
| [] -> cod
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))
let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) =
match bs with
| [b] -> pack_ln (Tv_Arrow b cod)
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))
let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) =
begin match inspect_comp c with
| C_Total t ->
begin match inspect_ln_unascribe t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_ln_bs : typ -> list binder * comp
let collect_arr_ln_bs t =
let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in
(List.Tot.Base.rev bs, c)
val collect_arr_ln : typ -> list typ * comp
let collect_arr_ln t =
let bs, c = collect_arr_ln_bs t in
List.Tot.Base.map type_of_binder bs, c
let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) =
match inspect_ln_unascribe t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs_ln : term -> list binder * term
let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)
let mk_stringlit (s : string) : term =
pack_ln (Tv_Const (C_String s))
let mk_strcat (t1 t2 : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]
let mk_cons (h t : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]
let mk_cons_t (ty h t : term) : term =
mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]
let rec mk_list (ts : list term) : term =
match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t::ts -> mk_cons t (mk_list ts)
let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term =
match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 -> let [x] = ts in x
| n -> begin
let qn = match n with
| 2 -> mktuple2_qn
| 3 -> mktuple3_qn
| 4 -> mktuple4_qn
| 5 -> mktuple5_qn
| 6 -> mktuple6_qn
| 7 -> mktuple7_qn
| 8 -> mktuple8_qn
in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts
end
let destruct_tuple (t : term) : option (list term) =
let head, args = collect_app_ln t in
match inspect_ln head with
| Tv_FVar fv ->
if List.Tot.Base.mem
(inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn;
mktuple6_qn; mktuple7_qn; mktuple8_qn]
then Some (List.Tot.Base.concatMap (fun (t, q) ->
match q with
| Q_Explicit -> [t]
| _ -> []) args)
else None
| _ -> None | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.Reflection.Const.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V2.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | t1: FStar.Stubs.Reflection.Types.term -> t2: FStar.Stubs.Reflection.Types.term
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Derived.mktuple_n",
"Prims.Cons",
"Prims.Nil"
] | [] | false | false | false | true | false | let mkpair (t1 t2: term) : term =
| mktuple_n [t1; t2] | false |
Vale.Stdcalls.X64.GCMdecryptOpt.fst | Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_lemma' | val gcm256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(iv: Ghost.erased supported_iv_LE)
(code: V.va_code)
(_win: bool)
(auth_b: b128)
(auth_bytes auth_num: uint64)
(keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128)
(len128x6_num: uint64)
(in128_b out128_b: b128)
(len128_num: uint64)
(inout_b: b128)
(cipher_num: uint64)
(scratch_b tag_b: b128)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0)
(ensures
(fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\
gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\
ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\
ME.buffer_writeable (as_vale_buffer hkeys_b) /\
ME.buffer_writeable (as_vale_buffer abytes_b) /\
ME.buffer_writeable (as_vale_buffer in128x6_b) /\
ME.buffer_writeable (as_vale_buffer out128x6_b) /\
ME.buffer_writeable (as_vale_buffer in128_b) /\
ME.buffer_writeable (as_vale_buffer out128_b) /\
ME.buffer_writeable (as_vale_buffer inout_b) /\
ME.buffer_writeable (as_vale_buffer scratch_b) /\
ME.buffer_writeable (as_vale_buffer tag_b))) | val gcm256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(iv: Ghost.erased supported_iv_LE)
(code: V.va_code)
(_win: bool)
(auth_b: b128)
(auth_bytes auth_num: uint64)
(keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128)
(len128x6_num: uint64)
(in128_b out128_b: b128)
(len128_num: uint64)
(inout_b: b128)
(cipher_num: uint64)
(scratch_b tag_b: b128)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0)
(ensures
(fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\
gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\
ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\
ME.buffer_writeable (as_vale_buffer hkeys_b) /\
ME.buffer_writeable (as_vale_buffer abytes_b) /\
ME.buffer_writeable (as_vale_buffer in128x6_b) /\
ME.buffer_writeable (as_vale_buffer out128x6_b) /\
ME.buffer_writeable (as_vale_buffer in128_b) /\
ME.buffer_writeable (as_vale_buffer out128_b) /\
ME.buffer_writeable (as_vale_buffer inout_b) /\
ME.buffer_writeable (as_vale_buffer scratch_b) /\
ME.buffer_writeable (as_vale_buffer tag_b))) | let gcm256_lemma'
(s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(code:V.va_code)
(_win:bool)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b
in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\
gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b
in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\
ME.buffer_writeable (as_vale_buffer auth_b) /\
ME.buffer_writeable (as_vale_buffer keys_b) /\
ME.buffer_writeable (as_vale_buffer iv_b) /\
ME.buffer_writeable (as_vale_buffer hkeys_b) /\
ME.buffer_writeable (as_vale_buffer abytes_b) /\
ME.buffer_writeable (as_vale_buffer in128x6_b) /\
ME.buffer_writeable (as_vale_buffer out128x6_b) /\
ME.buffer_writeable (as_vale_buffer in128_b) /\
ME.buffer_writeable (as_vale_buffer out128_b) /\
ME.buffer_writeable (as_vale_buffer inout_b) /\
ME.buffer_writeable (as_vale_buffer scratch_b) /\
ME.buffer_writeable (as_vale_buffer tag_b)
)) =
let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_256
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b)
(UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b)
(Ghost.reveal s) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b;
va_s1, f | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.GCMdecryptOpt.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 368,
"start_col": 0,
"start_line": 300
} | module Vale.Stdcalls.X64.GCMdecryptOpt
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
open FStar.Mul
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module GC = Vale.AES.X64.GCMdecryptOpt
open Vale.AES.AES_s
open Vale.AES.GCM_s
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
noextract
let as_t (#a:Type) (x:normal a) : a = x
noextract
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__] noextract
let b128 = buf_t TUInt8 TUInt128
[@__reduce__] noextract
let t128_mod = TD_Buffer TUInt8 TUInt128 default_bq
[@__reduce__] noextract
let t128_mod_pub = TD_Buffer TUInt8 TUInt128 ({modified=true; strict_disjointness=false; taint=MS.Public})
[@__reduce__] noextract
let t128_no_mod = TD_Buffer TUInt8 TUInt128 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__] noextract
let tuint64 = TD_Base TUInt64
[@__reduce__] noextract
let (dom: list td{List.length dom <= 20}) =
let y = [t128_no_mod; tuint64; tuint64; t128_no_mod; t128_mod_pub; t128_no_mod;
t128_no_mod; t128_no_mod; t128_mod; tuint64; t128_no_mod; t128_mod; tuint64; t128_mod; tuint64; t128_mod; t128_no_mod] in
assert_norm (List.length y = 17);
y
(* Need to rearrange the order of arguments *)
[@__reduce__] noextract
let gcm128_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom =
fun (s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(c:V.va_code)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state) ->
GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b)
(UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s)
[@__reduce__] noextract
let gcm128_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom =
fun (s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(c:V.va_code)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_128
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b)
(Ghost.reveal s) va_s1 f
#set-options "--z3rlimit 100"
[@__reduce__] noextract
let gcm128_lemma'
(s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(code:V.va_code)
(_win:bool)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
gcm128_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b
in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\
gcm128_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b
in128x6_b out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b va_s0 va_s1 f /\
ME.buffer_writeable (as_vale_buffer auth_b) /\
ME.buffer_writeable (as_vale_buffer keys_b) /\
ME.buffer_writeable (as_vale_buffer iv_b) /\
ME.buffer_writeable (as_vale_buffer hkeys_b) /\
ME.buffer_writeable (as_vale_buffer abytes_b) /\
ME.buffer_writeable (as_vale_buffer in128x6_b) /\
ME.buffer_writeable (as_vale_buffer out128x6_b) /\
ME.buffer_writeable (as_vale_buffer in128_b) /\
ME.buffer_writeable (as_vale_buffer out128_b) /\
ME.buffer_writeable (as_vale_buffer inout_b) /\
ME.buffer_writeable (as_vale_buffer scratch_b) /\
ME.buffer_writeable (as_vale_buffer tag_b)
)) =
let va_s1, f = GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_128
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b)
(UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b)
(Ghost.reveal s) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b;
va_s1, f
(* Prove that gcm128_lemma' has the required type *)
noextract
let gcm128_lemma (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) = as_t #(VSig.vale_sig_stdcall (gcm128_pre s iv) (gcm128_post s iv)) (gcm128_lemma' s iv)
noextract
let code_gcm128 = GC.va_code_Gcm_blocks_decrypt_stdcall IA.win AES_128
(* Here's the type expected for the gcm wrapper *)
[@__reduce__] noextract
let lowstar_gcm128_t (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) =
assert_norm (List.length dom + List.length ([]<:list arg) <= 20);
IX64.as_lowstar_sig_t_weak_stdcall
code_gcm128
dom
[]
_
_
(W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win))
(* And here's the gcm wrapper itself *)
noextract
let lowstar_gcm128 (s:Ghost.erased (Seq.seq nat32)) (iv:Ghost.erased supported_iv_LE) : lowstar_gcm128_t s iv =
assert_norm (List.length dom + List.length ([]<:list arg) <= 20);
IX64.wrap_weak_stdcall
code_gcm128
dom
(W.mk_prediction code_gcm128 dom [] ((gcm128_lemma s iv) code_gcm128 IA.win))
(* Need to rearrange the order of arguments *)
[@__reduce__] noextract
let gcm256_pre : (Ghost.erased (Seq.seq nat32)) -> (Ghost.erased supported_iv_LE) -> VSig.vale_pre dom =
fun (s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(c:V.va_code)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state) ->
GC.va_req_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b)
(UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s)
[@__reduce__] noextract
let gcm256_post : Ghost.erased (Seq.seq nat32) -> (Ghost.erased supported_iv_LE) -> VSig.vale_post dom =
fun (s:Ghost.erased (Seq.seq nat32))
(iv:Ghost.erased supported_iv_LE)
(c:V.va_code)
(auth_b:b128)
(auth_bytes:uint64)
(auth_num:uint64)
(keys_b:b128)
(iv_b:b128)
(hkeys_b:b128)
(abytes_b:b128)
(in128x6_b:b128)
(out128x6_b:b128)
(len128x6_num:uint64)
(in128_b:b128)
(out128_b:b128)
(len128_num:uint64)
(inout_b:b128)
(cipher_num:uint64)
(scratch_b:b128)
(tag_b:b128)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
GC.va_ens_Gcm_blocks_decrypt_stdcall c va_s0 IA.win AES_256
(as_vale_buffer auth_b) (UInt64.v auth_bytes)
(UInt64.v auth_num) (as_vale_buffer keys_b)
(as_vale_buffer iv_b) (Ghost.reveal iv) (as_vale_buffer hkeys_b)
(as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num)
(as_vale_buffer in128_b) (as_vale_buffer out128_b)
(UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b)
(Ghost.reveal s) va_s1 f
#set-options "--z3rlimit 100" | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"Vale.AES.X64.GCMdecryptOpt.fsti.checked",
"Vale.AES.GCM_s.fst.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.UInt64.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Stdcalls.X64.GCMdecryptOpt.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.GCM_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AES.X64.GCMdecryptOpt",
"short_module": "GC"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"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.Stdcalls.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Stdcalls.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: FStar.Ghost.erased (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) ->
iv: FStar.Ghost.erased Vale.AES.GCM_s.supported_iv_LE ->
code: Vale.X64.Decls.va_code ->
_win: Prims.bool ->
auth_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
auth_bytes: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 ->
auth_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 ->
keys_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
iv_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
hkeys_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
abytes_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
in128x6_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
out128x6_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
len128x6_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 ->
in128_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
out128_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
len128_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 ->
inout_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
cipher_num: Vale.Stdcalls.X64.GCMdecryptOpt.uint64 ->
scratch_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
tag_b: Vale.Stdcalls.X64.GCMdecryptOpt.b128 ->
va_s0: Vale.X64.Decls.va_state
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.AES.GCM_s.supported_iv_LE",
"Vale.X64.Decls.va_code",
"Prims.bool",
"Vale.Stdcalls.X64.GCMdecryptOpt.b128",
"Vale.Stdcalls.X64.GCMdecryptOpt.uint64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal",
"Vale.Arch.HeapTypes_s.TUInt8",
"Vale.Arch.HeapTypes_s.TUInt128",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.AES.X64.GCMdecryptOpt.va_lemma_Gcm_blocks_decrypt_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.AES.AES_common_s.AES_256",
"Vale.X64.MemoryAdapters.as_vale_buffer",
"FStar.UInt64.v",
"FStar.Ghost.reveal",
"Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_pre",
"Prims.l_and",
"Vale.X64.Decls.eval_code",
"Vale.AsLowStar.ValeSig.vale_calling_conventions_stdcall",
"Vale.Stdcalls.X64.GCMdecryptOpt.gcm256_post",
"Vale.X64.Memory.buffer_writeable"
] | [] | false | false | false | false | false | let gcm256_lemma'
(s: Ghost.erased (Seq.seq nat32))
(iv: Ghost.erased supported_iv_LE)
(code: V.va_code)
(_win: bool)
(auth_b: b128)
(auth_bytes auth_num: uint64)
(keys_b iv_b hkeys_b abytes_b in128x6_b out128x6_b: b128)
(len128x6_num: uint64)
(in128_b out128_b: b128)
(len128_num: uint64)
(inout_b: b128)
(cipher_num: uint64)
(scratch_b tag_b: b128)
(va_s0: V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
gcm256_pre s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0)
(ensures
(fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\
gcm256_post s iv code auth_b auth_bytes auth_num keys_b iv_b hkeys_b abytes_b in128x6_b
out128x6_b len128x6_num in128_b out128_b len128_num inout_b cipher_num scratch_b tag_b
va_s0 va_s1 f /\ ME.buffer_writeable (as_vale_buffer auth_b) /\
ME.buffer_writeable (as_vale_buffer keys_b) /\ ME.buffer_writeable (as_vale_buffer iv_b) /\
ME.buffer_writeable (as_vale_buffer hkeys_b) /\
ME.buffer_writeable (as_vale_buffer abytes_b) /\
ME.buffer_writeable (as_vale_buffer in128x6_b) /\
ME.buffer_writeable (as_vale_buffer out128x6_b) /\
ME.buffer_writeable (as_vale_buffer in128_b) /\
ME.buffer_writeable (as_vale_buffer out128_b) /\
ME.buffer_writeable (as_vale_buffer inout_b) /\
ME.buffer_writeable (as_vale_buffer scratch_b) /\
ME.buffer_writeable (as_vale_buffer tag_b))) =
| let va_s1, f =
GC.va_lemma_Gcm_blocks_decrypt_stdcall code va_s0 IA.win AES_256 (as_vale_buffer auth_b)
(UInt64.v auth_bytes) (UInt64.v auth_num) (as_vale_buffer keys_b) (as_vale_buffer iv_b)
(Ghost.reveal iv) (as_vale_buffer hkeys_b) (as_vale_buffer abytes_b) (as_vale_buffer in128x6_b)
(as_vale_buffer out128x6_b) (UInt64.v len128x6_num) (as_vale_buffer in128_b)
(as_vale_buffer out128_b) (UInt64.v len128_num) (as_vale_buffer inout_b) (UInt64.v cipher_num)
(as_vale_buffer scratch_b) (as_vale_buffer tag_b) (Ghost.reveal s)
in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 auth_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 keys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 iv_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 hkeys_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 abytes_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128x6_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 in128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 out128_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 inout_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 scratch_b;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt8 ME.TUInt128 tag_b;
va_s1, f | false |
FStar.Reflection.V2.Derived.fst | FStar.Reflection.V2.Derived.is_any_fvar | val is_any_fvar (t: term) (nms: list string) : bool | val is_any_fvar (t: term) (nms: list string) : bool | let rec is_any_fvar (t : term) (nms:list string) : bool =
match nms with
| [] -> false
| v::vs -> is_fvar t v || is_any_fvar t vs | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 241,
"start_col": 0,
"start_line": 238
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V2.Derived
open FStar.Stubs.Reflection.Types
open FStar.Reflection.Const
open FStar.Stubs.Reflection.V2.Builtins
open FStar.Stubs.Reflection.V2.Data
open FStar.Order
open FStar.VConfig
let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} =
match inspect_ln t with
| Tv_AscribedT t' _ _ _
| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv
let compare_bv (v1 v2 : bv) : order =
Order.compare_int (inspect_bv v1).index (inspect_bv v2).index
let compare_namedv (v1 v2 : namedv) : order =
Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq
let shift n s = match s with
| DB i t -> DB (i+n) t
| DT i t -> DT (i+n) t
| UN i t -> UN (i+n) t
| NM x i -> NM x (i+n)
| UD x i -> UD x (i+n)
| NT _ _ -> s
let shift_subst n s = List.Tot.map (shift n) s
let subst1 (n:namedv) (t1:term) (t2:term) : term =
subst_term [NT n t1] t2
(*
* AR: add versions that take attributes as arguments?
*)
let mk_binder (nm : string) (sort : typ) : simple_binder =
let bv : binder_view = {
ppname = seal nm;
qual = Q_Explicit;
attrs = [];
sort = sort;
}
in
inspect_pack_binder bv;
pack_binder bv
let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
}
let push_binding (e:env) (b:binding) : env =
let nv : namedv = pack_namedv {
uniq = b.uniq;
sort = seal b.sort;
ppname = b.ppname;
}
in
push_namedv e nv
let type_of_binder (b : binder) : typ =
(inspect_binder b).sort
val flatten_name : name -> Tot string
let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) =
match inspect_ln_unascribe t with
| Tv_App l r ->
collect_app_ln' (r::args) l
| _ -> (t, args)
val collect_app_ln : term -> term * list argv
let collect_app_ln = collect_app_ln' []
let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) =
match args with
| [] -> t
| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs
// Helper for when all arguments are explicit
let mk_e_app (t : term) (args : list term) : Tot term =
let e t = (t, Q_Explicit) in
mk_app t (List.Tot.Base.map e args)
let u_unk : universe = pack_universe Uv_Unk
let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) =
match bs with
| [] -> cod
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))
let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) =
match bs with
| [b] -> pack_ln (Tv_Arrow b cod)
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))
let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) =
begin match inspect_comp c with
| C_Total t ->
begin match inspect_ln_unascribe t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_ln_bs : typ -> list binder * comp
let collect_arr_ln_bs t =
let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in
(List.Tot.Base.rev bs, c)
val collect_arr_ln : typ -> list typ * comp
let collect_arr_ln t =
let bs, c = collect_arr_ln_bs t in
List.Tot.Base.map type_of_binder bs, c
let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) =
match inspect_ln_unascribe t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs_ln : term -> list binder * term
let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)
let mk_stringlit (s : string) : term =
pack_ln (Tv_Const (C_String s))
let mk_strcat (t1 t2 : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]
let mk_cons (h t : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]
let mk_cons_t (ty h t : term) : term =
mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]
let rec mk_list (ts : list term) : term =
match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t::ts -> mk_cons t (mk_list ts)
let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term =
match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 -> let [x] = ts in x
| n -> begin
let qn = match n with
| 2 -> mktuple2_qn
| 3 -> mktuple3_qn
| 4 -> mktuple4_qn
| 5 -> mktuple5_qn
| 6 -> mktuple6_qn
| 7 -> mktuple7_qn
| 8 -> mktuple8_qn
in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts
end
let destruct_tuple (t : term) : option (list term) =
let head, args = collect_app_ln t in
match inspect_ln head with
| Tv_FVar fv ->
if List.Tot.Base.mem
(inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn;
mktuple6_qn; mktuple7_qn; mktuple8_qn]
then Some (List.Tot.Base.concatMap (fun (t, q) ->
match q with
| Q_Explicit -> [t]
| _ -> []) args)
else None
| _ -> None
let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2]
let rec head (t : term) : term =
match inspect_ln t with
| Tv_Match t _ _
| Tv_Let _ _ _ t _
| Tv_Abs _ t
| Tv_Refine _ t
| Tv_App t _
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ -> head t
| Tv_Unknown
| Tv_Uvar _ _
| Tv_Const _
| Tv_Type _
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_UInst _ _
| Tv_Arrow _ _
| Tv_Unsupp -> t
(** Checks if a term `t` is equal to some FV (a top level name).
Ignores universes and ascriptions. *)
let is_fvar (t : term) (nm:string) : bool =
match inspect_ln_unascribe t with
| Tv_FVar fv
| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm
| _ -> false
(** Checks if a term `t` is equal to any FV (a top level name) from | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.Reflection.Const.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V2.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | t: FStar.Stubs.Reflection.Types.term -> nms: Prims.list Prims.string -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"Prims.list",
"Prims.string",
"Prims.op_BarBar",
"FStar.Reflection.V2.Derived.is_fvar",
"FStar.Reflection.V2.Derived.is_any_fvar",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec is_any_fvar (t: term) (nms: list string) : bool =
| match nms with
| [] -> false
| v :: vs -> is_fvar t v || is_any_fvar t vs | false |
FStar.Reflection.V2.Derived.fst | FStar.Reflection.V2.Derived.maybe_unsquash_term | val maybe_unsquash_term (t: term) : term | val maybe_unsquash_term (t: term) : term | let maybe_unsquash_term (t : term) : term =
match unsquash_term t with
| Some t' -> t'
| None -> t | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 295,
"start_col": 0,
"start_line": 292
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V2.Derived
open FStar.Stubs.Reflection.Types
open FStar.Reflection.Const
open FStar.Stubs.Reflection.V2.Builtins
open FStar.Stubs.Reflection.V2.Data
open FStar.Order
open FStar.VConfig
let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} =
match inspect_ln t with
| Tv_AscribedT t' _ _ _
| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv
let compare_bv (v1 v2 : bv) : order =
Order.compare_int (inspect_bv v1).index (inspect_bv v2).index
let compare_namedv (v1 v2 : namedv) : order =
Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq
let shift n s = match s with
| DB i t -> DB (i+n) t
| DT i t -> DT (i+n) t
| UN i t -> UN (i+n) t
| NM x i -> NM x (i+n)
| UD x i -> UD x (i+n)
| NT _ _ -> s
let shift_subst n s = List.Tot.map (shift n) s
let subst1 (n:namedv) (t1:term) (t2:term) : term =
subst_term [NT n t1] t2
(*
* AR: add versions that take attributes as arguments?
*)
let mk_binder (nm : string) (sort : typ) : simple_binder =
let bv : binder_view = {
ppname = seal nm;
qual = Q_Explicit;
attrs = [];
sort = sort;
}
in
inspect_pack_binder bv;
pack_binder bv
let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
}
let push_binding (e:env) (b:binding) : env =
let nv : namedv = pack_namedv {
uniq = b.uniq;
sort = seal b.sort;
ppname = b.ppname;
}
in
push_namedv e nv
let type_of_binder (b : binder) : typ =
(inspect_binder b).sort
val flatten_name : name -> Tot string
let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) =
match inspect_ln_unascribe t with
| Tv_App l r ->
collect_app_ln' (r::args) l
| _ -> (t, args)
val collect_app_ln : term -> term * list argv
let collect_app_ln = collect_app_ln' []
let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) =
match args with
| [] -> t
| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs
// Helper for when all arguments are explicit
let mk_e_app (t : term) (args : list term) : Tot term =
let e t = (t, Q_Explicit) in
mk_app t (List.Tot.Base.map e args)
let u_unk : universe = pack_universe Uv_Unk
let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) =
match bs with
| [] -> cod
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))
let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) =
match bs with
| [b] -> pack_ln (Tv_Arrow b cod)
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))
let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) =
begin match inspect_comp c with
| C_Total t ->
begin match inspect_ln_unascribe t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_ln_bs : typ -> list binder * comp
let collect_arr_ln_bs t =
let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in
(List.Tot.Base.rev bs, c)
val collect_arr_ln : typ -> list typ * comp
let collect_arr_ln t =
let bs, c = collect_arr_ln_bs t in
List.Tot.Base.map type_of_binder bs, c
let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) =
match inspect_ln_unascribe t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs_ln : term -> list binder * term
let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)
let mk_stringlit (s : string) : term =
pack_ln (Tv_Const (C_String s))
let mk_strcat (t1 t2 : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]
let mk_cons (h t : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]
let mk_cons_t (ty h t : term) : term =
mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]
let rec mk_list (ts : list term) : term =
match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t::ts -> mk_cons t (mk_list ts)
let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term =
match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 -> let [x] = ts in x
| n -> begin
let qn = match n with
| 2 -> mktuple2_qn
| 3 -> mktuple3_qn
| 4 -> mktuple4_qn
| 5 -> mktuple5_qn
| 6 -> mktuple6_qn
| 7 -> mktuple7_qn
| 8 -> mktuple8_qn
in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts
end
let destruct_tuple (t : term) : option (list term) =
let head, args = collect_app_ln t in
match inspect_ln head with
| Tv_FVar fv ->
if List.Tot.Base.mem
(inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn;
mktuple6_qn; mktuple7_qn; mktuple8_qn]
then Some (List.Tot.Base.concatMap (fun (t, q) ->
match q with
| Q_Explicit -> [t]
| _ -> []) args)
else None
| _ -> None
let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2]
let rec head (t : term) : term =
match inspect_ln t with
| Tv_Match t _ _
| Tv_Let _ _ _ t _
| Tv_Abs _ t
| Tv_Refine _ t
| Tv_App t _
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ -> head t
| Tv_Unknown
| Tv_Uvar _ _
| Tv_Const _
| Tv_Type _
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_UInst _ _
| Tv_Arrow _ _
| Tv_Unsupp -> t
(** Checks if a term `t` is equal to some FV (a top level name).
Ignores universes and ascriptions. *)
let is_fvar (t : term) (nm:string) : bool =
match inspect_ln_unascribe t with
| Tv_FVar fv
| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm
| _ -> false
(** Checks if a term `t` is equal to any FV (a top level name) from
those given in the list. Ignores universes and ascriptions. *)
let rec is_any_fvar (t : term) (nms:list string) : bool =
match nms with
| [] -> false
| v::vs -> is_fvar t v || is_any_fvar t vs
let is_uvar (t : term) : bool =
match inspect_ln (head t) with
| Tv_Uvar _ _ -> true
| _ -> false
let binder_set_qual (q:aqualv) (b:binder) : Tot binder =
let bview = inspect_binder b in
pack_binder { bview with qual=q }
(** Set a vconfig for a sigelt *)
val add_check_with : vconfig -> sigelt -> Tot sigelt
let add_check_with vcfg se =
let attrs = sigelt_attrs se in
let vcfg_t = embed_vconfig vcfg in
let t = `(check_with (`#vcfg_t)) in
set_sigelt_attrs (t :: attrs) se
let un_uinst (t:term) : term =
match inspect_ln t with
| Tv_UInst fv _ -> pack_ln (Tv_FVar fv)
| _ -> t
(* Returns [true] iff the term [t] is just the name [nm], though
possibly universe-instantiated and applied to some implicit arguments.
*)
let rec is_name_imp (nm : name) (t : term) : bool =
begin match inspect_ln_unascribe t with
| Tv_FVar fv
| Tv_UInst fv _ ->
if inspect_fv fv = nm
then true
else false
| Tv_App l (_, Q_Implicit) ->
is_name_imp nm l
| _ -> false
end
(* If t is of the shape [squash t'], return [Some t'],
otherwise [None]. *)
let unsquash_term (t : term) : option term =
match inspect_ln_unascribe t with
| Tv_App l (r, Q_Explicit) ->
if is_name_imp squash_qn l
then Some r
else None
| _ -> None
(* As [unsquash_term], but returns the original term if | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.Reflection.Const.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V2.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Derived.unsquash_term"
] | [] | false | false | false | true | false | let maybe_unsquash_term (t: term) : term =
| match unsquash_term t with
| Some t' -> t'
| None -> t | false |
Spec.Frodo.Random.fst | Spec.Frodo.Random.state_t | val state_t : Type0 | let state_t = seq uint8 | {
"file_name": "specs/frodo/Spec.Frodo.Random.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 6,
"start_col": 0,
"start_line": 6
} | module Spec.Frodo.Random
open Lib.IntTypes
open Lib.Sequence | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Random.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.seq",
"Lib.IntTypes.uint8"
] | [] | false | false | false | true | true | let state_t =
| seq uint8 | false |
|
FStar.Reflection.V2.Derived.fst | FStar.Reflection.V2.Derived.is_name_imp | val is_name_imp (nm: name) (t: term) : bool | val is_name_imp (nm: name) (t: term) : bool | let rec is_name_imp (nm : name) (t : term) : bool =
begin match inspect_ln_unascribe t with
| Tv_FVar fv
| Tv_UInst fv _ ->
if inspect_fv fv = nm
then true
else false
| Tv_App l (_, Q_Implicit) ->
is_name_imp nm l
| _ -> false
end | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 278,
"start_col": 0,
"start_line": 268
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V2.Derived
open FStar.Stubs.Reflection.Types
open FStar.Reflection.Const
open FStar.Stubs.Reflection.V2.Builtins
open FStar.Stubs.Reflection.V2.Data
open FStar.Order
open FStar.VConfig
let rec inspect_ln_unascribe (t:term) : tv:term_view{tv << t /\ notAscription tv} =
match inspect_ln t with
| Tv_AscribedT t' _ _ _
| Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv
let compare_bv (v1 v2 : bv) : order =
Order.compare_int (inspect_bv v1).index (inspect_bv v2).index
let compare_namedv (v1 v2 : namedv) : order =
Order.compare_int (inspect_namedv v1).uniq (inspect_namedv v2).uniq
let shift n s = match s with
| DB i t -> DB (i+n) t
| DT i t -> DT (i+n) t
| UN i t -> UN (i+n) t
| NM x i -> NM x (i+n)
| UD x i -> UD x (i+n)
| NT _ _ -> s
let shift_subst n s = List.Tot.map (shift n) s
let subst1 (n:namedv) (t1:term) (t2:term) : term =
subst_term [NT n t1] t2
(*
* AR: add versions that take attributes as arguments?
*)
let mk_binder (nm : string) (sort : typ) : simple_binder =
let bv : binder_view = {
ppname = seal nm;
qual = Q_Explicit;
attrs = [];
sort = sort;
}
in
inspect_pack_binder bv;
pack_binder bv
let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
}
let push_binding (e:env) (b:binding) : env =
let nv : namedv = pack_namedv {
uniq = b.uniq;
sort = seal b.sort;
ppname = b.ppname;
}
in
push_namedv e nv
let type_of_binder (b : binder) : typ =
(inspect_binder b).sort
val flatten_name : name -> Tot string
let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app_ln' (args : list argv) (t : term) : Tot (term * list argv) (decreases t) =
match inspect_ln_unascribe t with
| Tv_App l r ->
collect_app_ln' (r::args) l
| _ -> (t, args)
val collect_app_ln : term -> term * list argv
let collect_app_ln = collect_app_ln' []
let rec mk_app (t : term) (args : list argv) : Tot term (decreases args) =
match args with
| [] -> t
| (x::xs) -> mk_app (pack_ln (Tv_App t x)) xs
// Helper for when all arguments are explicit
let mk_e_app (t : term) (args : list term) : Tot term =
let e t = (t, Q_Explicit) in
mk_app t (List.Tot.Base.map e args)
let u_unk : universe = pack_universe Uv_Unk
let rec mk_tot_arr_ln (bs: list binder) (cod : term) : Tot term (decreases bs) =
match bs with
| [] -> cod
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod))))
let rec mk_arr_ln (bs: list binder{~(Nil? bs)}) (cod : comp) : Tot term (decreases bs) =
match bs with
| [b] -> pack_ln (Tv_Arrow b cod)
| (b::bs) -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_arr_ln bs cod))))
let rec collect_arr' (bs : list binder) (c : comp) : Tot (list binder * comp) (decreases c) =
begin match inspect_comp c with
| C_Total t ->
begin match inspect_ln_unascribe t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_ln_bs : typ -> list binder * comp
let collect_arr_ln_bs t =
let (bs, c) = collect_arr' [] (pack_comp (C_Total t)) in
(List.Tot.Base.rev bs, c)
val collect_arr_ln : typ -> list typ * comp
let collect_arr_ln t =
let bs, c = collect_arr_ln_bs t in
List.Tot.Base.map type_of_binder bs, c
let rec collect_abs' (bs : list binder) (t : term) : Tot (list binder * term) (decreases t) =
match inspect_ln_unascribe t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs_ln : term -> list binder * term
let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
let fv_to_string (fv:fv) : string = implode_qn (inspect_fv fv)
let mk_stringlit (s : string) : term =
pack_ln (Tv_Const (C_String s))
let mk_strcat (t1 t2 : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv ["Prims"; "strcat"]))) [t1; t2]
let mk_cons (h t : term) : term =
mk_e_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [h; t]
let mk_cons_t (ty h t : term) : term =
mk_app (pack_ln (Tv_FVar (pack_fv cons_qn))) [(ty, Q_Implicit); (h, Q_Explicit); (t, Q_Explicit)]
let rec mk_list (ts : list term) : term =
match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t::ts -> mk_cons t (mk_list ts)
let mktuple_n (ts : list term{List.Tot.Base.length ts <= 8}) : term =
match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 -> let [x] = ts in x
| n -> begin
let qn = match n with
| 2 -> mktuple2_qn
| 3 -> mktuple3_qn
| 4 -> mktuple4_qn
| 5 -> mktuple5_qn
| 6 -> mktuple6_qn
| 7 -> mktuple7_qn
| 8 -> mktuple8_qn
in mk_e_app (pack_ln (Tv_FVar (pack_fv qn))) ts
end
let destruct_tuple (t : term) : option (list term) =
let head, args = collect_app_ln t in
match inspect_ln head with
| Tv_FVar fv ->
if List.Tot.Base.mem
(inspect_fv fv) [mktuple2_qn; mktuple3_qn; mktuple4_qn; mktuple5_qn;
mktuple6_qn; mktuple7_qn; mktuple8_qn]
then Some (List.Tot.Base.concatMap (fun (t, q) ->
match q with
| Q_Explicit -> [t]
| _ -> []) args)
else None
| _ -> None
let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2]
let rec head (t : term) : term =
match inspect_ln t with
| Tv_Match t _ _
| Tv_Let _ _ _ t _
| Tv_Abs _ t
| Tv_Refine _ t
| Tv_App t _
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ -> head t
| Tv_Unknown
| Tv_Uvar _ _
| Tv_Const _
| Tv_Type _
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_UInst _ _
| Tv_Arrow _ _
| Tv_Unsupp -> t
(** Checks if a term `t` is equal to some FV (a top level name).
Ignores universes and ascriptions. *)
let is_fvar (t : term) (nm:string) : bool =
match inspect_ln_unascribe t with
| Tv_FVar fv
| Tv_UInst fv _ -> implode_qn (inspect_fv fv) = nm
| _ -> false
(** Checks if a term `t` is equal to any FV (a top level name) from
those given in the list. Ignores universes and ascriptions. *)
let rec is_any_fvar (t : term) (nms:list string) : bool =
match nms with
| [] -> false
| v::vs -> is_fvar t v || is_any_fvar t vs
let is_uvar (t : term) : bool =
match inspect_ln (head t) with
| Tv_Uvar _ _ -> true
| _ -> false
let binder_set_qual (q:aqualv) (b:binder) : Tot binder =
let bview = inspect_binder b in
pack_binder { bview with qual=q }
(** Set a vconfig for a sigelt *)
val add_check_with : vconfig -> sigelt -> Tot sigelt
let add_check_with vcfg se =
let attrs = sigelt_attrs se in
let vcfg_t = embed_vconfig vcfg in
let t = `(check_with (`#vcfg_t)) in
set_sigelt_attrs (t :: attrs) se
let un_uinst (t:term) : term =
match inspect_ln t with
| Tv_UInst fv _ -> pack_ln (Tv_FVar fv)
| _ -> t
(* Returns [true] iff the term [t] is just the name [nm], though
possibly universe-instantiated and applied to some implicit arguments. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.Reflection.Const.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V2.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | nm: FStar.Stubs.Reflection.Types.name -> t: FStar.Stubs.Reflection.Types.term -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.name",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Stubs.Reflection.Types.fv",
"Prims.op_Equality",
"FStar.Stubs.Reflection.V2.Builtins.inspect_fv",
"Prims.bool",
"FStar.Stubs.Reflection.V2.Data.universes",
"FStar.Reflection.V2.Derived.is_name_imp",
"FStar.Stubs.Reflection.V2.Data.term_view"
] | [
"recursion"
] | false | false | false | true | false | let rec is_name_imp (nm: name) (t: term) : bool =
| match inspect_ln_unascribe t with
| Tv_FVar fv | Tv_UInst fv _ -> if inspect_fv fv = nm then true else false
| Tv_App l (_, Q_Implicit) -> is_name_imp nm l
| _ -> false | false |
Hacl.Impl.SHA2.Core.fst | Hacl.Impl.SHA2.Core.load_blocks4 | val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4}
-> b:multibuf (lanes a m) (HD.block_len a)
-> ws:ws_t a m ->
Stack unit
(requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws)
(ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\
as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) | val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4}
-> b:multibuf (lanes a m) (HD.block_len a)
-> ws:ws_t a m ->
Stack unit
(requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws)
(ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\
as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) | let load_blocks4 #a #m ib ws =
let h0 = ST.get() in
let (b0,(b1,(b2,b3))) = NTup.tup4 ib in
set_wsi ws 0ul b0 0ul;
set_wsi ws 1ul b1 0ul;
set_wsi ws 2ul b2 0ul;
set_wsi ws 3ul b3 0ul;
set_wsi ws 4ul b0 1ul;
set_wsi ws 5ul b1 1ul;
set_wsi ws 6ul b2 1ul;
let h1 = ST.get() in
assert (modifies (loc ws) h0 h1);
set_wsi ws 7ul b3 1ul;
set_wsi ws 8ul b0 2ul;
set_wsi ws 9ul b1 2ul;
set_wsi ws 10ul b2 2ul;
set_wsi ws 11ul b3 2ul;
set_wsi ws 12ul b0 3ul;
set_wsi ws 13ul b1 3ul;
set_wsi ws 14ul b2 3ul;
set_wsi ws 15ul b3 3ul;
let h1 = ST.get() in
assert (modifies (loc ws) h0 h1);
LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec4 (as_seq_multi h0 ib));
load_blocks_spec4_lemma #a #m (as_seq_multi h0 ib);
assert (as_seq h1 ws == load_blocks_spec4 (as_seq_multi h0 ib));
assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib));
() | {
"file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 199,
"start_col": 0,
"start_line": 172
} | module Hacl.Impl.SHA2.Core
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.IntVector
open Lib.MultiBuffer
open Spec.Hash.Definitions
//open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq
open Hacl.Spec.SHA2.Vec
module ST = FStar.HyperStack.ST
module NTup = Lib.NTuple
module SpecVec = Hacl.Spec.SHA2.Vec
module VecTranspose = Lib.IntVector.Transpose
module LSeq = Lib.Sequence
module HD = Hacl.Hash.Definitions
(* Force ordering in dependency analysis so that monomorphizations are inserted
into the Types module first. *)
let _ = Hacl.Impl.SHA2.Types.uint8_8p
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
unfold
let state_t (a:sha2_alg) (m:m_spec) =
lbuffer (element_t a m) 8ul
unfold
let block_t (a:sha2_alg) =
lbuffer uint8 (HD.block_len a)
inline_for_extraction noextract
let ws_t (a:sha2_alg) (m:m_spec) =
lbuffer (element_t a m) 16ul
inline_for_extraction noextract
val set_wsi: #a:sha2_alg -> #m:m_spec
-> ws:ws_t a m
-> i:size_t{v i < 16}
-> b:lbuffer uint8 (HD.block_len a)
-> bi:size_t{v bi < 16 / (lanes a m)} ->
Stack unit
(requires fun h -> live h b /\ live h ws /\ disjoint b ws)
(ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\
as_seq h1 ws == LSeq.upd (as_seq h0 ws) (v i) (SpecVec.load_elementi #a #m (as_seq h0 b) (v bi)))
let set_wsi #a #m ws i b bi =
[@inline_let]
let l = lanes a m in
ws.(i) <- vec_load_be (word_t a) l (sub b (bi *! size l *! HD.word_len a) (size l *! HD.word_len a))
noextract
let load_blocks_spec1 (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) : ws_spec a m =
let b = b.(|0|) in
let ws0 = SpecVec.load_elementi b 0 in
let ws1 = SpecVec.load_elementi b 1 in
let ws2 = SpecVec.load_elementi b 2 in
let ws3 = SpecVec.load_elementi b 3 in
let ws4 = SpecVec.load_elementi b 4 in
let ws5 = SpecVec.load_elementi b 5 in
let ws6 = SpecVec.load_elementi b 6 in
let ws7 = SpecVec.load_elementi b 7 in
let ws8 = SpecVec.load_elementi b 8 in
let ws9 = SpecVec.load_elementi b 9 in
let ws10 = SpecVec.load_elementi b 10 in
let ws11 = SpecVec.load_elementi b 11 in
let ws12 = SpecVec.load_elementi b 12 in
let ws13 = SpecVec.load_elementi b 13 in
let ws14 = SpecVec.load_elementi b 14 in
let ws15 = SpecVec.load_elementi b 15 in
LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7
ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15
noextract
let load_blocks_spec1_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 1}) (b:multiblock_spec a m) :
Lemma (SpecVec.load_blocks b == load_blocks_spec1 b)
=
LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec1 b)
#push-options "--z3rlimit 100"
inline_for_extraction noextract
val load_blocks1: #a:sha2_alg -> #m:m_spec{lanes a m == 1}
-> b:multibuf (lanes a m) (HD.block_len a)
-> ws:ws_t a m ->
Stack unit
(requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws)
(ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\
as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b))
let load_blocks1 #a #m ib ws =
let h0 = ST.get() in
let b = ib.(|0|) in
set_wsi ws 0ul b 0ul;
set_wsi ws 1ul b 1ul;
set_wsi ws 2ul b 2ul;
set_wsi ws 3ul b 3ul;
set_wsi ws 4ul b 4ul;
set_wsi ws 5ul b 5ul;
set_wsi ws 6ul b 6ul;
let h1 = ST.get() in
assert (modifies (loc ws) h0 h1);
set_wsi ws 7ul b 7ul;
set_wsi ws 8ul b 8ul;
set_wsi ws 9ul b 9ul;
set_wsi ws 10ul b 10ul;
set_wsi ws 11ul b 11ul;
set_wsi ws 12ul b 12ul;
set_wsi ws 13ul b 13ul;
set_wsi ws 14ul b 14ul;
set_wsi ws 15ul b 15ul;
let h1 = ST.get() in
assert (modifies (loc ws) h0 h1);
LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec1 (as_seq_multi h0 ib));
load_blocks_spec1_lemma #a #m (as_seq_multi h0 ib);
assert (as_seq h1 ws == load_blocks_spec1 (as_seq_multi h0 ib));
assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib))
#pop-options
noextract
let load_blocks_spec4 (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) : ws_spec a m =
let b0 = b.(|0|) in
let b1 = b.(|1|) in
let b2 = b.(|2|) in
let b3 = b.(|3|) in
let ws0 = SpecVec.load_elementi b0 0 in
let ws1 = SpecVec.load_elementi b1 0 in
let ws2 = SpecVec.load_elementi b2 0 in
let ws3 = SpecVec.load_elementi b3 0 in
let ws4 = SpecVec.load_elementi b0 1 in
let ws5 = SpecVec.load_elementi b1 1 in
let ws6 = SpecVec.load_elementi b2 1 in
let ws7 = SpecVec.load_elementi b3 1 in
let ws8 = SpecVec.load_elementi b0 2 in
let ws9 = SpecVec.load_elementi b1 2 in
let ws10 = SpecVec.load_elementi b2 2 in
let ws11 = SpecVec.load_elementi b3 2 in
let ws12 = SpecVec.load_elementi b0 3 in
let ws13 = SpecVec.load_elementi b1 3 in
let ws14 = SpecVec.load_elementi b2 3 in
let ws15 = SpecVec.load_elementi b3 3 in
LSeq.create16 ws0 ws1 ws2 ws3 ws4 ws5 ws6 ws7
ws8 ws9 ws10 ws11 ws12 ws13 ws14 ws15
noextract
let load_blocks_spec4_lemma (#a:sha2_alg) (#m:m_spec{lanes a m == 4}) (b:multiblock_spec a m) :
Lemma (SpecVec.load_blocks b == load_blocks_spec4 b)
=
LSeq.eq_intro (SpecVec.load_blocks b) (load_blocks_spec4 b)
inline_for_extraction noextract
val load_blocks4: #a:sha2_alg -> #m:m_spec{lanes a m == 4}
-> b:multibuf (lanes a m) (HD.block_len a)
-> ws:ws_t a m ->
Stack unit
(requires fun h -> live_multi h b /\ live h ws /\ disjoint_multi b ws)
(ensures fun h0 _ h1 -> modifies (loc ws) h0 h1 /\
as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 b)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntVector.Transpose.fsti.checked",
"Lib.IntVector.Serialize.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.Impl.SHA2.Types.fst.checked",
"Hacl.Hash.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.SHA2.Core.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "HD"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.IntVector.Transpose",
"short_module": "VecTranspose"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": true,
"full_module": "Lib.NTuple",
"short_module": "NTup"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Lib.MultiBuffer.multibuf (Hacl.Spec.SHA2.Vec.lanes a m) (Hacl.Hash.Definitions.block_len a) ->
ws: Hacl.Impl.SHA2.Core.ws_t a m
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.MultiBuffer.multibuf",
"Hacl.Hash.Definitions.block_len",
"Hacl.Impl.SHA2.Core.ws_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Prims.unit",
"Prims._assert",
"Lib.Sequence.lseq",
"Hacl.Spec.SHA2.Vec.element_t",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.SHA2.Vec.load_blocks",
"Lib.MultiBuffer.as_seq_multi",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.SHA2.Core.load_blocks_spec4",
"Hacl.Impl.SHA2.Core.load_blocks_spec4_lemma",
"Lib.Sequence.eq_intro",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.SHA2.Core.set_wsi",
"FStar.Pervasives.Native.tuple2",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.NTuple.tup4"
] | [] | false | true | false | false | false | let load_blocks4 #a #m ib ws =
| let h0 = ST.get () in
let b0, (b1, (b2, b3)) = NTup.tup4 ib in
set_wsi ws 0ul b0 0ul;
set_wsi ws 1ul b1 0ul;
set_wsi ws 2ul b2 0ul;
set_wsi ws 3ul b3 0ul;
set_wsi ws 4ul b0 1ul;
set_wsi ws 5ul b1 1ul;
set_wsi ws 6ul b2 1ul;
let h1 = ST.get () in
assert (modifies (loc ws) h0 h1);
set_wsi ws 7ul b3 1ul;
set_wsi ws 8ul b0 2ul;
set_wsi ws 9ul b1 2ul;
set_wsi ws 10ul b2 2ul;
set_wsi ws 11ul b3 2ul;
set_wsi ws 12ul b0 3ul;
set_wsi ws 13ul b1 3ul;
set_wsi ws 14ul b2 3ul;
set_wsi ws 15ul b3 3ul;
let h1 = ST.get () in
assert (modifies (loc ws) h0 h1);
LSeq.eq_intro (as_seq h1 ws) (load_blocks_spec4 (as_seq_multi h0 ib));
load_blocks_spec4_lemma #a #m (as_seq_multi h0 ib);
assert (as_seq h1 ws == load_blocks_spec4 (as_seq_multi h0 ib));
assert (as_seq h1 ws == SpecVec.load_blocks (as_seq_multi h0 ib));
() | false |
LowParse.Low.Array.fst | LowParse.Low.Array.finalize_vlarray | val finalize_vlarray
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
(let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\
(let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\
(let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/
(elem_count_min <= count /\ count <= elem_count_max)))))))
(ensures
(fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\
L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h'
sl
pos
l
pos')) | val finalize_vlarray
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
(let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\
(let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\
(let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/
(elem_count_min <= count /\ count <= elem_count_max)))))))
(ensures
(fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\
L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h'
sl
pos
l
pos')) | let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 209,
"end_line": 478,
"start_col": 0,
"start_line": 436
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_synth",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.Array.vldata_to_vlarray",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.VLData.finalize_bounded_vldata_strong_exact",
"LowParse.Spec.Array.vlarray_to_vldata_correct",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.List.Tot.Base.length",
"FStar.Classical.move_requires",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Spec.Array.vlarray_pred",
"LowParse.Spec.Array.vldata_to_vlarray_correct",
"LowParse.Low.Base.Spec.valid_exact_serialize",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.List.valid_list_valid_exact_list",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"Prims.op_LessThan",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.UInt32.v",
"Prims.l_or",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.parse_vlarray"
] | [] | false | true | false | false | false | let finalize_vlarray
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
(let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\
(let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\
(let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/
(elem_count_min <= count /\ count <= elem_count_max)))))))
(ensures
(fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\ elem_count_min <= L.length l /\
L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h'
sl
pos
l
pos')) =
| let h = HST.get () in
let pos1 = pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max)) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _:squash (let count = L.length (Ghost.reveal l) in
elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos';
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max)
(Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min
array_byte_size_max
(serialize_list _ s)
sl
pos
pos';
let h = HST.get () in
valid_synth h
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sl
pos | false |
LowParse.Low.Array.fst | LowParse.Low.Array.array_nth_ghost_correct' | val array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size elem_count: nat)
(i:
nat
{ fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input))
(ensures
(gaccessor_post' (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input
(array_nth_ghost'' s array_byte_size elem_count i input))) | val array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size elem_count: nat)
(i:
nat
{ fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input))
(ensures
(gaccessor_post' (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input
(array_nth_ghost'' s array_byte_size elem_count i input))) | let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input)) | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 107,
"end_line": 108,
"start_col": 0,
"start_line": 83
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: LowParse.Spec.Base.serializer p ->
array_byte_size: Prims.nat ->
elem_count: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count } ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Array.parse_array s
array_byte_size
elem_count)
p
(LowParse.Low.Array.clens_array_nth t elem_count i)
input)
(ensures
LowParse.Low.Base.Spec.gaccessor_post' (LowParse.Spec.Array.parse_array s
array_byte_size
elem_count)
p
(LowParse.Low.Array.clens_array_nth t elem_count i)
input
(LowParse.Low.Array.array_nth_ghost'' s array_byte_size elem_count i input)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.nat",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.fldata_array_precond",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_strong_prefix",
"FStar.Seq.Base.slice",
"LowParse.Bytes.byte",
"FStar.Seq.Base.length",
"Prims.int",
"Prims.op_Multiply",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.unit",
"LowParse.Low.Array.list_nth_constant_size_parser_correct",
"LowParse.Spec.FLData.parse_fldata_kind",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.FLData.parse_fldata_strong_t",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"LowParse.Spec.FLData.parse_fldata_strong",
"FStar.Seq.Base.seq",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Array.array",
"LowParse.Spec.Array.fldata_to_array",
"LowParse.Spec.Array.fldata_to_array_inj",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Array.array_nth_ghost''",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Array.parse_array_kind",
"LowParse.Spec.Array.parse_array",
"LowParse.Low.Array.clens_array_nth",
"Prims.squash",
"LowParse.Low.Base.Spec.gaccessor_post'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size elem_count: nat)
(i:
nat
{ fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\ elem_count < 4294967296 /\ i < elem_count })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input))
(ensures
(gaccessor_post' (parse_array s array_byte_size elem_count)
p
(clens_array_nth t elem_count i)
input
(array_nth_ghost'' s array_byte_size elem_count i input))) =
| reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size)
(fldata_to_array s array_byte_size elem_count ())
input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p
(Seq.slice input0 off (Seq.length input0))
(Seq.slice input off (Seq.length input)) | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_body | val vlarray_nth_body
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: Ghost.erased bytes)
: Pure U32.t
(requires
(Seq.length (Ghost.reveal input) < 4294967296 /\
gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max (U32.v i))
(Ghost.reveal input)))
(ensures
(fun y ->
U32.v y ==
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i)
(Ghost.reveal input)))) | val vlarray_nth_body
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: Ghost.erased bytes)
: Pure U32.t
(requires
(Seq.length (Ghost.reveal input) < 4294967296 /\
gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max (U32.v i))
(Ghost.reveal input)))
(ensures
(fun y ->
U32.v y ==
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i)
(Ghost.reveal input)))) | let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input))) | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 139,
"end_line": 622,
"start_col": 0,
"start_line": 592
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
FStar.UInt32.t
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true } ->
input: FStar.Ghost.erased LowParse.Bytes.bytes
-> Prims.Pure FStar.UInt32.t | Prims.Pure | [] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"FStar.Ghost.erased",
"LowParse.Bytes.bytes",
"LowParse.Low.Array.vlarray_nth_compute",
"LowParse.Spec.BoundedInt.log256'",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Ghost.hide",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.op_Multiply",
"FStar.UInt32.v",
"LowParse.Low.Array.list_nth_constant_size_parser_correct",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.BoundedInt.bounded_integer",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parse",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"Prims.unit",
"LowParse.Spec.Array.parse_vlarray_eq_some",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Array.vlarray_nth_ghost''",
"Prims.l_and",
"Prims.op_LessThan",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_GreaterThanOrEqual"
] | [] | false | false | false | false | false | let vlarray_nth_body
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: Ghost.erased bytes)
: Pure U32.t
(requires
(Seq.length (Ghost.reveal input) < 4294967296 /\
gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max (U32.v i))
(Ghost.reveal input)))
(ensures
(fun y ->
U32.v y ==
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i)
(Ghost.reveal input)))) =
| reveal_opaque (`%vlarray_nth_ghost'')
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i)
(Ghost.reveal input));
[@@ inline_let ]let _:squash ((log256' array_byte_size_max +
((U32.v i) `Prims.op_Multiply` k.parser_kind_low) +
k.parser_kind_low) <=
Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
()
(Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq =
Seq.slice (Ghost.reveal input)
(log256' array_byte_size_max)
(log256' array_byte_size_max + U32.v len)
in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max)
i
(U32.uint_to_t k.parser_kind_low)
(Ghost.hide (Seq.length (Ghost.reveal input))) | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_list_length | val vlarray_list_length
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
valid (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos))
(ensures
(fun h res h' ->
let x =
(contents (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos)
in
let pos' =
get_valid_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos
in
B.modifies B.loc_none h h' /\ U32.v res == L.length x /\
U32.v pos' ==
U32.v pos + (log256' array_byte_size_max) +
((U32.v res) `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' /\
contents_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' ==
x)) | val vlarray_list_length
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
valid (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos))
(ensures
(fun h res h' ->
let x =
(contents (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos)
in
let pos' =
get_valid_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos
in
B.modifies B.loc_none h h' /\ U32.v res == L.length x /\
U32.v pos' ==
U32.v pos + (log256' array_byte_size_max) +
((U32.v res) `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' /\
contents_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' ==
x)) | let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 21,
"end_line": 545,
"start_col": 0,
"start_line": 491
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.UInt32.div",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Low.BoundedInt.read_bounded_integer",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.unit",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.List.valid_exact_list_valid_list",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Spec.List.parse_list_kind",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"FStar.UInt32.add",
"FStar.Math.Lemmas.multiple_division_lemma",
"FStar.List.Tot.Base.length",
"LowParse.Spec.List.list_length_constant_size_parser_correct",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.VLData.parse_vldata_gen_eq",
"LowParse.Spec.BoundedInt.in_bounds",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.List.serialize_list",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.Array.vldata_to_vlarray",
"LowParse.Spec.Array.vldata_to_vlarray_inj",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.contents",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Mul.op_Star",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.Spec.get_valid_pos"
] | [] | false | true | false | false | false | let vlarray_list_length
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true /\
valid (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos))
(ensures
(fun h res h' ->
let x =
(contents (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos)
in
let pos' =
get_valid_pos (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos
in
B.modifies B.loc_none h h' /\ U32.v res == L.length x /\
U32.v pos' ==
U32.v pos + (log256' array_byte_size_max) +
((U32.v res) `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' /\
contents_list p h sl (pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max))) pos' ==
x)) =
| let h = HST.get () in
[@@ inline_let ]let _:unit =
let l =
contents (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos
in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
h
sl
pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq (parse_bounded_vldata_strong array_byte_size_min
array_byte_size_max
(serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max)
(in_bounds array_byte_size_min array_byte_size_max)
(parse_list p)
sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p
(Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` (U32.uint_to_t (log256' array_byte_size_max)) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@@ inline_let ]let klow:U32.t = U32.uint_to_t k.parser_kind_low in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_ghost' | val vlarray_nth_ghost'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) | val vlarray_nth_ghost'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) | let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 101,
"end_line": 693,
"start_col": 0,
"start_line": 677
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true }
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Bytes.bytes",
"LowParse.Low.Array.vlarray_nth_ghost''",
"Prims.unit",
"LowParse.Low.Array.vlarray_nth_ghost_correct",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth"
] | [] | false | false | false | false | false | let vlarray_nth_ghost'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) =
| fun input ->
reveal_opaque (`%vlarray_nth_ghost'')
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input);
vlarray_nth_ghost_correct array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input;
vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_ghost_correct | val vlarray_nth_ghost_correct
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) | val vlarray_nth_ghost_correct
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) | let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 134,
"end_line": 674,
"start_col": 0,
"start_line": 658
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true } ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Base.Spec.gaccessor_post' (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i)
input
(LowParse.Low.Array.vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Bytes.bytes",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Low.Array.vlarray_nth_ghost''",
"LowParse.Low.Array.vlarray_nth_ghost_correct'",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let vlarray_nth_ghost_correct
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) =
| reveal_opaque (`%vlarray_nth_ghost'')
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i)
input | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_ghost | val vlarray_nth_ghost
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) | val vlarray_nth_ghost
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) | let vlarray_nth_ghost
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 94,
"end_line": 740,
"start_col": 0,
"start_line": 723
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true }
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Low.Array.vlarray_nth_ghost'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"FStar.Classical.forall_intro",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Low.Base.Spec.gaccessor_pre",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"LowParse.Spec.BoundedInt.log256'",
"Prims.op_Multiply",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Classical.move_requires",
"LowParse.Low.Array.vlarray_nth_bound",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Array.vlarray_nth_ghost''",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let vlarray_nth_ghost
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(gaccessor (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)) =
| reveal_opaque (`%vlarray_nth_ghost')
(vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'')
(vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
(vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth | val vlarray_nth
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(accessor (vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i))) | val vlarray_nth
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(accessor (vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i))) | let vlarray_nth
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (accessor (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i)))
= reveal_opaque (`%vlarray_nth_ghost) (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
make_accessor_from_pure
(vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i))
(fun input ->
vlarray_nth_body array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
) | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 762,
"start_col": 0,
"start_line": 743
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i
[@"opaque_to_smt"]
let vlarray_nth_ghost
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
FStar.UInt32.t
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true }
-> LowParse.Low.Base.accessor (LowParse.Low.Array.vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(FStar.UInt32.v i)) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Low.Base.make_accessor_from_pure",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"FStar.UInt32.v",
"LowParse.Low.Array.vlarray_nth_ghost",
"FStar.Ghost.erased",
"LowParse.Bytes.bytes",
"LowParse.Low.Array.vlarray_nth_body",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Low.Array.vlarray_nth_ghost'",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor"
] | [] | false | false | false | false | false | let vlarray_nth
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
U32.t
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
: Tot
(accessor (vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i))) =
| reveal_opaque (`%vlarray_nth_ghost)
(vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i));
reveal_opaque (`%vlarray_nth_ghost')
(vlarray_nth_ghost' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i));
make_accessor_from_pure (vlarray_nth_ghost array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
(U32.v i))
(fun input ->
vlarray_nth_body array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input) | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_bound | val vlarray_nth_bound
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(x: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
x))
(ensures
(log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <=
Seq.length x)) | val vlarray_nth_bound
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(x: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
x))
(ensures
(log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <=
Seq.length x)) | let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 50,
"end_line": 720,
"start_col": 0,
"start_line": 695
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true } ->
x: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i)
x)
(ensures
LowParse.Spec.BoundedInt.log256' array_byte_size_max + i * Mkparser_kind'?.parser_kind_low k +
Mkparser_kind'?.parser_kind_low k <=
FStar.Seq.Base.length x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Bytes.bytes",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.Array.list_nth_constant_size_parser_correct",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.parse",
"LowParse.Spec.List.parse_list",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Pervasives.Native.option",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Array.parse_vlarray_eq_some",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"Prims.squash",
"Prims.op_LessThanOrEqual",
"Prims.op_Multiply",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let vlarray_nth_bound
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(x: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
x))
(ensures
(log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <=
Seq.length x)) =
| parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i | false |
LowParse.Low.Array.fst | LowParse.Low.Array.valid_bounded_vldata_strong_list_valid_list | val valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\ True)
)) | val valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\ True)
)) | let valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
U32.v pos + log256' max <= U32.v pos' /\ (
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' == contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True
)))
= valid_bounded_vldata_strong_elim h min max (serialize_list _ s) input pos;
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
valid_exact_list_valid_list p h input pos1 pos' | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 49,
"end_line": 792,
"start_col": 0,
"start_line": 766
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i
[@"opaque_to_smt"]
let vlarray_nth_ghost
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i
inline_for_extraction
let vlarray_nth
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (accessor (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i)))
= reveal_opaque (`%vlarray_nth_ghost) (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
make_accessor_from_pure
(vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i))
(fun input ->
vlarray_nth_body array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
)
module HS = FStar.HyperStack | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
p: LowParse.Spec.Base.parser k t ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLData.parse_bounded_vldata_strong min
max
(LowParse.Spec.List.serialize_list p s))
h
input
pos)
(ensures
(let pos' =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.VLData.parse_bounded_vldata_strong min
max
(LowParse.Spec.List.serialize_list p s))
h
input
pos
in
FStar.UInt32.v pos + LowParse.Spec.BoundedInt.log256' max <= FStar.UInt32.v pos' /\
(let pos1 =
FStar.UInt32.add pos (FStar.UInt32.uint_to_t (LowParse.Spec.BoundedInt.log256' max))
in
LowParse.Low.Base.Spec.valid_list p h input pos1 pos' /\
LowParse.Low.Base.Spec.contents_list p h input pos1 pos' ==
LowParse.Low.Base.Spec.contents (LowParse.Spec.VLData.parse_bounded_vldata_strong min
max
(LowParse.Spec.List.serialize_list p s))
h
input
pos /\ Prims.l_True))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.List.valid_exact_list_valid_list",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"Prims.unit",
"LowParse.Low.VLData.valid_bounded_vldata_strong_elim",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.Spec.contents",
"Prims.l_True",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\ True)
)) =
| valid_bounded_vldata_strong_elim h min max (serialize_list _ s) input pos;
let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
valid_exact_list_valid_list p h input pos1 pos' | false |
LowParse.Low.Array.fst | LowParse.Low.Array.finalize_bounded_vldata_strong_list | val finalize_bounded_vldata_strong_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = log256' max in
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_list p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize (serialize_list _ s)
(contents_list p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos_payload) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = log256' max in
let x = contents_list p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\
Seq.length (serialize (serialize_list _ s) x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max (serialize_list _ s) x /\
valid_content_pos (parse_bounded_vldata_strong min max (serialize_list _ s))
h'
input
pos
x
pos')) | val finalize_bounded_vldata_strong_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = log256' max in
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_list p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize (serialize_list _ s)
(contents_list p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos_payload) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = log256' max in
let x = contents_list p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\
Seq.length (serialize (serialize_list _ s) x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max (serialize_list _ s) x /\
valid_content_pos (parse_bounded_vldata_strong min max (serialize_list _ s))
h'
input
pos
x
pos')) | let finalize_bounded_vldata_strong_list
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = log256' max in
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_list p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize (serialize_list _ s) (contents_list p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos_payload) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = log256' max in
let x = contents_list p h input (pos `U32.add` U32.uint_to_t sz) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` U32.uint_to_t sz)) h h' /\
Seq.length (serialize (serialize_list _ s) x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max (serialize_list _ s) x /\
valid_content_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let] let _ = valid_list_valid_exact_list p h input (pos `U32.add` U32.uint_to_t (log256' max)) pos' in
finalize_bounded_vldata_strong_exact min max (serialize_list _ s) input pos pos' | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 82,
"end_line": 863,
"start_col": 0,
"start_line": 831
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i
[@"opaque_to_smt"]
let vlarray_nth_ghost
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i
inline_for_extraction
let vlarray_nth
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (accessor (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i)))
= reveal_opaque (`%vlarray_nth_ghost) (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
make_accessor_from_pure
(vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i))
(fun input ->
vlarray_nth_body array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
)
module HS = FStar.HyperStack
let valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
U32.v pos + log256' max <= U32.v pos' /\ (
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' == contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True
)))
= valid_bounded_vldata_strong_elim h min max (serialize_list _ s) input pos;
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
valid_exact_list_valid_list p h input pos1 pos'
inline_for_extraction
let bounded_vldata_strong_list_payload_size
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
))
(ensures (fun h res h' ->
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
B.modifies B.loc_none h h' /\
U32.v pos + log256' max <= U32.v pos' /\ (
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
res == pos' `U32.sub` pos1 /\
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' == contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True
)))
= let h = HST.get () in
let pos' = jump_bounded_vldata_strong min max (serialize_list _ s) () input pos in
[@inline_let]
let _ =
assert (valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos pos')
in
[@inline_let] let _ = valid_bounded_vldata_strong_list_valid_list min max p s input pos h in
[@inline_let] let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
[@inline_let] let res = pos' `U32.sub` pos1 in
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.VLData.finalize_bounded_vldata_strong_exact",
"LowParse.Spec.List.parse_list_kind",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"Prims.unit",
"LowParse.Low.List.valid_list_valid_exact_list",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.BoundedInt.log256'",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"Prims.l_or",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.contents_list",
"FStar.UInt32.sub",
"LowParse.Spec.BoundedInt.integer_size",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLData.parse_bounded_vldata_strong"
] | [] | false | true | false | false | false | let finalize_bounded_vldata_strong_list
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = log256' max in
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_list p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize (serialize_list _ s)
(contents_list p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos_payload) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = log256' max in
let x = contents_list p h input (pos `U32.add` (U32.uint_to_t sz)) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` (U32.uint_to_t sz))) h h' /\
Seq.length (serialize (serialize_list _ s) x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max (serialize_list _ s) x /\
valid_content_pos (parse_bounded_vldata_strong min max (serialize_list _ s))
h'
input
pos
x
pos')) =
| let h = HST.get () in
[@@ inline_let ]let _ =
valid_list_valid_exact_list p h input (pos `U32.add` (U32.uint_to_t (log256' max))) pos'
in
finalize_bounded_vldata_strong_exact min max (serialize_list _ s) input pos pos' | false |
LowParse.Low.Array.fst | LowParse.Low.Array.bounded_vldata_strong_list_payload_size | val bounded_vldata_strong_list_payload_size
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h -> valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(fun h res h' ->
let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
B.modifies B.loc_none h h' /\ U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
res == pos' `U32.sub` pos1 /\ valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True))) | val bounded_vldata_strong_list_payload_size
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h -> valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(fun h res h' ->
let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
B.modifies B.loc_none h h' /\ U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
res == pos' `U32.sub` pos1 /\ valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True))) | let bounded_vldata_strong_list_payload_size
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
))
(ensures (fun h res h' ->
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
B.modifies B.loc_none h h' /\
U32.v pos + log256' max <= U32.v pos' /\ (
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
res == pos' `U32.sub` pos1 /\
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' == contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True
)))
= let h = HST.get () in
let pos' = jump_bounded_vldata_strong min max (serialize_list _ s) () input pos in
[@inline_let]
let _ =
assert (valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos pos')
in
[@inline_let] let _ = valid_bounded_vldata_strong_list_valid_list min max p s input pos h in
[@inline_let] let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
[@inline_let] let res = pos' `U32.sub` pos1 in
res | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 828,
"start_col": 0,
"start_line": 795
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32"
let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
)
#pop-options
let vlarray_nth_ghost_correct
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
Classical.move_requires (vlarray_nth_ghost_correct' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i) input
[@"opaque_to_smt"]
let vlarray_nth_ghost'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= fun input ->
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
vlarray_nth_ghost_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input;
vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
let vlarray_nth_bound
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(x: bytes)
: Lemma
(requires (
gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) x
))
(ensures (
log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x
))
= parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () x;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) x in
let input' = Seq.slice x (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i
[@"opaque_to_smt"]
let vlarray_nth_ghost
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (gaccessor (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i))
= reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
Classical.forall_intro (Classical.move_requires (vlarray_nth_bound array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i));
gaccessor_prop_equiv (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i);
vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i
inline_for_extraction
let vlarray_nth
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
: Tot (accessor (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i)))
= reveal_opaque (`%vlarray_nth_ghost) (vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
reveal_opaque (`%vlarray_nth_ghost') (vlarray_nth_ghost' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i));
make_accessor_from_pure
(vlarray_nth_ghost array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i))
(fun input ->
vlarray_nth_body array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input
)
module HS = FStar.HyperStack
let valid_bounded_vldata_strong_list_valid_list
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
U32.v pos + log256' max <= U32.v pos' /\ (
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' == contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True
)))
= valid_bounded_vldata_strong_elim h min max (serialize_list _ s) input pos;
let pos1 = pos `U32.add` U32.uint_to_t (log256' max) in
let pos' = get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos in
valid_exact_list_valid_list p h input pos1 pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
p: LowParse.Spec.Base.parser k t ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.UInt32.sub",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.BoundedInt.log256'",
"Prims.unit",
"LowParse.Low.Array.valid_bounded_vldata_strong_list_valid_list",
"Prims._assert",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims.list",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Low.VLData.jump_bounded_vldata_strong",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.Spec.contents",
"Prims.l_True",
"LowParse.Low.Base.Spec.get_valid_pos"
] | [] | false | true | false | false | false | let bounded_vldata_strong_list_payload_size
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h -> valid (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos))
(ensures
(fun h res h' ->
let pos' =
get_valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos
in
B.modifies B.loc_none h h' /\ U32.v pos + log256' max <= U32.v pos' /\
(let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
res == pos' `U32.sub` pos1 /\ valid_list p h input pos1 pos' /\
contents_list p h input pos1 pos' ==
contents (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos /\
True))) =
| let h = HST.get () in
let pos' = jump_bounded_vldata_strong min max (serialize_list _ s) () input pos in
[@@ inline_let ]let _ =
assert (valid_pos (parse_bounded_vldata_strong min max (serialize_list _ s)) h input pos pos')
in
[@@ inline_let ]let _ = valid_bounded_vldata_strong_list_valid_list min max p s input pos h in
[@@ inline_let ]let pos1 = pos `U32.add` (U32.uint_to_t (log256' max)) in
[@@ inline_let ]let res = pos' `U32.sub` pos1 in
res | false |
LowParse.Low.Array.fst | LowParse.Low.Array.vlarray_nth_ghost_correct' | val vlarray_nth_ghost_correct'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input))
(ensures
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input))) | val vlarray_nth_ghost_correct'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input))
(ensures
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input))) | let vlarray_nth_ghost_correct'
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input))
(ensures (gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)))
= reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input);
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p (Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input')) (Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (
gaccessor_post' (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max i) input (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max i input)
) | {
"file_name": "src/lowparse/LowParse.Low.Array.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 654,
"start_col": 0,
"start_line": 628
} | module LowParse.Low.Array
include LowParse.Spec.Array
include LowParse.Low.List
include LowParse.Low.VLData
module L = FStar.List.Tot
module M = LowParse.Math
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
#reset-options "--z3cliopt smt.arith.nl=false --z3rlimit 16"
val list_nth_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
(i: nat)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b) /\ (
let (Some (l, _)) = parse (parse_list p) b in
i < L.length l
)))
(ensures (
let j = i `Prims.op_Multiply` k.parser_kind_low in
0 <= j /\
j + k.parser_kind_low <= Seq.length b /\ (
let b' = Seq.slice b j (Seq.length b) in
Some? (parse p b') /\ (
let (Some (l, _)) = parse (parse_list p) b in
let (Some (x, _)) = parse p b' in
x == L.index l i
))))
(decreases i)
let rec list_nth_constant_size_parser_correct #k #t p b i =
parser_kind_prop_equiv k p;
parse_list_eq p b;
if i = 0
then ()
else begin
M.mult_decomp i k.parser_kind_low;
list_nth_constant_size_parser_correct p (Seq.slice b k.parser_kind_low (Seq.length b)) (i - 1)
end
let clens_array_nth
(t: Type)
(elem_count: nat)
(i: nat { i < elem_count } )
: Tot (clens (array t elem_count) t)
= {
clens_cond = (fun _ -> True);
clens_get = (fun (l: array t elem_count) -> L.index l i);
}
#reset-options // re-enable non-linear arith to prove that multiplying two nats yields a nat
[@"opaque_to_smt"]
let array_nth_ghost''
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: GTot (nat)
= if (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length input
then (i `Prims.op_Multiply` k.parser_kind_low)
else (0) // dummy
#reset-options "--z3cliopt smt.arith.nl=false"
let array_nth_ghost_correct'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(requires (gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input))
(ensures (gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input)))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
parser_kind_prop_equiv k p;
fldata_to_array_inj s array_byte_size elem_count ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input;
let input0 = Seq.slice input 0 array_byte_size in
parse_strong_prefix (parse_fldata_strong (serialize_list _ s) array_byte_size) input input0;
list_nth_constant_size_parser_correct p input0 i;
let off = i `Prims.op_Multiply` k.parser_kind_low in
parse_strong_prefix p (Seq.slice input0 off (Seq.length input0)) (Seq.slice input off (Seq.length input))
let array_nth_ghost_correct
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
(input: bytes)
: Lemma
(gaccessor_post' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) input (array_nth_ghost'' s array_byte_size elem_count i input))
= reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i input);
Classical.move_requires (array_nth_ghost_correct' s array_byte_size elem_count i) input
[@"opaque_to_smt"]
let array_nth_ghost'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor' (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= fun input ->
array_nth_ghost_correct s array_byte_size elem_count i input;
array_nth_ghost'' s array_byte_size elem_count i input
[@"opaque_to_smt"]
let array_nth_ghost
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: nat {
fldata_array_precond k array_byte_size elem_count == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
i < elem_count
})
: Tot (gaccessor (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i))
= reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s array_byte_size elem_count i);
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s array_byte_size elem_count i);
M.distributivity_add_left i 1 k.parser_kind_low;
M.lemma_mult_le_right k.parser_kind_low (i + 1) elem_count;
assert ((i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= array_byte_size);
parser_kind_prop_equiv (parse_array_kind' array_byte_size) (parse_array s array_byte_size elem_count);
assert (forall x . gaccessor_pre (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) x ==> (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low <= Seq.length x);
gaccessor_prop_equiv (parse_array s array_byte_size elem_count) p (clens_array_nth t elem_count i) (array_nth_ghost' s array_byte_size elem_count i);
array_nth_ghost' s array_byte_size elem_count i
module B = LowStar.Buffer
inline_for_extraction
let array_nth
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(elem_count: nat)
(i: U32.t {
fldata_array_precond k (array_byte_size) (elem_count) == true /\
array_byte_size < 4294967296 /\
elem_count < 4294967296 /\
U32.v i < elem_count
})
: Tot (accessor (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)))
= fun #rrel #rel input pos ->
reveal_opaque (`%array_nth_ghost) (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost') (array_nth_ghost' s (array_byte_size) (elem_count) (U32.v i));
reveal_opaque (`%array_nth_ghost'') (array_nth_ghost'' s (array_byte_size) (elem_count) (U32.v i));
let h = HST.get () in
[@inline_let] let _ =
parser_kind_prop_equiv k p;
valid_facts (parse_array s (array_byte_size) (elem_count)) h input pos;
slice_access_eq h (array_nth_ghost s (array_byte_size) (elem_count) (U32.v i)) input pos;
fldata_to_array_inj s (array_byte_size) (elem_count) ();
parse_synth_eq (parse_fldata_strong (serialize_list _ s) (array_byte_size)) (fldata_to_array s array_byte_size elem_count ()) (bytes_of_slice_from h input pos);
list_nth_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 array_byte_size) (U32.v i)
in
pos `U32.add` (i `U32.mul` U32.uint_to_t k.parser_kind_low)
module HS = FStar.HyperStack
let valid_list_valid_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array' s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_exact_list p h input pos pos' ;
valid_exact_equiv (parse_list p) h input pos pos' ;
let len32 = pos' `U32.sub` pos in
list_length_constant_size_parser_correct p (Seq.slice (bytes_of_slice_from h input pos) 0 (U32.v len32));
contents_exact_eq (parse_list p) h input pos pos';
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos
let valid_list_valid_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h input pos pos' /\ (L.length (contents_list p h input pos pos') == elem_count \/ U32.v pos' - U32.v pos == array_byte_size)))
(ensures (
let x = contents_list p h input pos pos' in
L.length x == elem_count /\
U32.v pos' - U32.v pos == array_byte_size /\
valid_content_pos (parse_array s array_byte_size elem_count) h input pos x pos'
))
= valid_list_valid_array' s array_byte_size array_byte_size32 elem_count u h input pos pos' ;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_facts (parse_array s array_byte_size elem_count) h input pos
let valid_array_valid_list'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array' s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
let pos' = get_valid_pos (parse_array' s array_byte_size elem_count) h input pos in
let x = contents (parse_array' s array_byte_size elem_count) h input pos in
valid_synth h (parse_fldata_strong (serialize_list _ s) array_byte_size) (fldata_to_array s array_byte_size elem_count ()) input pos;
valid_facts (parse_fldata_strong (serialize_list _ s) array_byte_size) h input pos;
valid_exact_equiv (parse_list p) h input pos pos' ;
contents_exact_eq (parse_list p) h input pos pos' ;
valid_exact_list_valid_list p h input pos pos'
let valid_array_valid_list
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_array s array_byte_size elem_count) h input pos
))
(ensures (
let pos' = get_valid_pos (parse_array s array_byte_size elem_count) h input pos in
let x = contents (parse_array s array_byte_size elem_count) h input pos in
U32.v pos' - U32.v pos == array_byte_size /\
valid_list p h input pos pos' /\
contents_list p h input pos pos' == x
))
=
valid_facts (parse_array s array_byte_size elem_count) h input pos;
valid_facts (parse_array' s array_byte_size elem_count) h input pos;
valid_array_valid_list' s array_byte_size array_byte_size32 elem_count u h input pos
inline_for_extraction
let validate_array'
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array' s array_byte_size elem_count))
= validate_synth
(validate_fldata_strong (serialize_list _ s) (validate_list v ()) array_byte_size array_byte_size32)
(fldata_to_array s array_byte_size elem_count ())
()
inline_for_extraction
let validate_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (validator (parse_array s array_byte_size elem_count))
= if k.parser_kind_metadata = Some ParserKindMetadataTotal
then validate_total_constant_size (parse_array s array_byte_size elem_count) (FStar.Int.Cast.uint32_to_uint64 array_byte_size32) ()
else validate_array' s v array_byte_size array_byte_size32 elem_count u
inline_for_extraction
let jump_array
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(array_byte_size: nat)
(array_byte_size32: U32.t)
(elem_count: nat)
(u: unit {
fldata_array_precond k array_byte_size elem_count == true /\
U32.v array_byte_size32 == array_byte_size
})
: Tot (jumper (parse_array s array_byte_size elem_count))
= jump_constant_size (parse_array s array_byte_size elem_count) array_byte_size32 ()
inline_for_extraction
let validate_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max /\ array_byte_size_max < 4294967296 } )
: Tot (validator (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
validate_synth
(validate_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) (validate_list v ()) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let jump_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(u: unit {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(sz32: U32.t { U32.v sz32 == log256' array_byte_size_max } )
: Tot (jumper (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u))
= vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max u;
jump_synth
(jump_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s) ())
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
()
inline_for_extraction
let finalize_vlarray
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\ (
let vpos1 = U32.v pos + log256' array_byte_size_max in
vpos1 < 4294967296 /\ (
let pos1 = U32.uint_to_t vpos1 in
let len = U32.v pos' - vpos1 in
valid_list p h sl pos1 pos' /\ (
let count = L.length (contents_list p h sl pos1 pos') in
writable sl.base (U32.v pos) vpos1 h /\
((array_byte_size_min <= len /\ len <= array_byte_size_max) \/ (elem_count_min <= count /\ count <= elem_count_max))
)))))
(ensures (fun h _ h' ->
let pos1 = (U32.uint_to_t (U32.v pos + log256' array_byte_size_max)) in
let l = contents_list p h sl pos1 pos' in
B.modifies (loc_slice_from_to sl pos pos1) h h' /\
elem_count_min <= L.length l /\ L.length l <= elem_count_max /\
valid_content_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h' sl pos l pos'
))
= let h = HST.get () in
let pos1 = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
valid_list_valid_exact_list p h sl pos1 pos';
let l = Ghost.hide (contents_list p h sl pos1 pos') in
let _ : squash (let count = L.length (Ghost.reveal l) in elem_count_min <= count /\ count <= elem_count_max) =
valid_exact_serialize (serialize_list _ s) h sl pos1 pos' ;
Classical.move_requires (vldata_to_vlarray_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max) (Ghost.reveal l)
in
vlarray_to_vldata_correct array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (Ghost.reveal l);
finalize_bounded_vldata_strong_exact array_byte_size_min array_byte_size_max (serialize_list _ s) sl pos pos' ;
let h = HST.get () in
valid_synth h (parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s)) (vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) sl pos
let clens_vlarray_nth
(t: Type)
(min max: nat)
(i: nat)
: Tot (clens (vlarray t min max) t)
= {
clens_cond = (fun (l: vlarray t min max) -> i < L.length l);
clens_get = (fun (l: vlarray t min max) -> L.index l i);
}
inline_for_extraction
let vlarray_list_length
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true /\
valid (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos
))
(ensures (fun h res h' ->
let x = (contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos) in
let pos' = get_valid_pos (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
B.modifies B.loc_none h h' /\
U32.v res == L.length x /\
U32.v pos' == U32.v pos + (log256' array_byte_size_max) + (U32.v res `FStar.Mul.op_Star` k.parser_kind_low) /\
valid_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' /\
contents_list p h sl (pos `U32.add` U32.uint_to_t (log256' array_byte_size_max)) pos' == x
))
= let h = HST.get () in
[@inline_let]
let _ : unit =
let l = contents (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos in
let sq = bytes_of_slice_from h sl pos in
valid_facts (parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) h sl pos;
valid_facts (parse_bounded_integer (log256' array_byte_size_max)) h sl pos;
vldata_to_vlarray_inj array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ();
parse_synth_eq
(parse_bounded_vldata_strong array_byte_size_min array_byte_size_max (serialize_list _ s))
(vldata_to_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ())
sq;
parse_vldata_gen_eq (log256' array_byte_size_max) (in_bounds array_byte_size_min array_byte_size_max) (parse_list p) sq;
let psq = parse (parse_bounded_integer (log256' array_byte_size_max)) sq in
let Some (ln, _) = psq in
list_length_constant_size_parser_correct p (Seq.slice sq (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v ln));
LowParse.Math.multiple_division_lemma (L.length l) k.parser_kind_low;
let pos_payload = pos `U32.add` U32.uint_to_t (log256' array_byte_size_max) in
let pos' = pos_payload `U32.add` ln in
valid_exact_equiv (parse_list p) h sl pos_payload pos';
contents_exact_eq (parse_list p) h sl pos_payload pos';
valid_exact_list_valid_list p h sl pos_payload pos'
in
[@inline_let]
let klow : U32.t =
U32.uint_to_t k.parser_kind_low
in
let blen = read_bounded_integer (log256' array_byte_size_max) sl pos in
blen `U32.div` klow
#push-options "--z3rlimit 16"
[@"opaque_to_smt"]
let vlarray_nth_ghost''
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: nat {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: bytes)
: GTot (nat)
= if (log256' array_byte_size_max + (i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length input
then (log256' array_byte_size_max + (i `M.mult_nat` k.parser_kind_low))
else (0) // dummy
#pop-options
let uint32_size_intro
(x: nat)
: Lemma
(requires (x < 4294967296))
(ensures (FStar.UInt.size x 32))
= ()
inline_for_extraction
let vlarray_nth_compute
(a: nat)
(b: U32.t)
(c: U32.t)
(bound: Ghost.erased nat {
a + (U32.v b `Prims.op_Multiply` U32.v c) <= Ghost.reveal bound /\
Ghost.reveal bound < 4294967296
})
: Tot (z: U32.t { U32.v z == a + (U32.v b `Prims.op_Multiply` U32.v c)})
= FStar.Math.Lemmas.nat_times_nat_is_nat (U32.v b) (U32.v c);
uint32_size_intro (U32.v b `Prims.op_Multiply` U32.v c);
U32.uint_to_t a `U32.add` (b `U32.mul` c)
inline_for_extraction
let vlarray_nth_body
(array_byte_size_min: nat)
(array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min: nat)
(elem_count_max: nat)
(i: U32.t {
vldata_vlarray_precond array_byte_size_min array_byte_size_max p elem_count_min elem_count_max == true
})
(input: Ghost.erased bytes)
: Pure U32.t
(requires (Seq.length (Ghost.reveal input) < 4294967296 /\ gaccessor_pre
(parse_vlarray array_byte_size_min array_byte_size_max s elem_count_min elem_count_max ()) p (clens_vlarray_nth t elem_count_min elem_count_max (U32.v i)) (Ghost.reveal input)))
(ensures (fun y ->
U32.v y == (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input))))
=
reveal_opaque (`%vlarray_nth_ghost'') (vlarray_nth_ghost'' array_byte_size_min array_byte_size_max s elem_count_min elem_count_max (U32.v i) (Ghost.reveal input));
[@inline_let]
let _ : squash ((log256' array_byte_size_max + (U32.v i `Prims.op_Multiply` k.parser_kind_low) + k.parser_kind_low) <= Seq.length (Ghost.reveal input)) =
parse_vlarray_eq_some array_byte_size_min array_byte_size_max s elem_count_min elem_count_max () (Ghost.reveal input);
let pi = parse (parse_bounded_integer (log256' array_byte_size_max)) (Ghost.reveal input) in
let lc = Some?.v pi in
let len = fst lc in
let c_len = snd lc in
let sq = Seq.slice (Ghost.reveal input) (log256' array_byte_size_max) (log256' array_byte_size_max + U32.v len) in
list_nth_constant_size_parser_correct p sq (U32.v i)
in
vlarray_nth_compute (log256' array_byte_size_max) i (U32.uint_to_t k.parser_kind_low) (Ghost.hide (Seq.length (Ghost.reveal input)))
#reset-options "--z3cliopt smt.arith.nl=false --z3refresh --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
#push-options "--z3rlimit 32" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Array.fst.checked",
"LowParse.Math.fst.checked",
"LowParse.Low.VLData.fst.checked",
"LowParse.Low.List.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Array.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
array_byte_size_min: Prims.nat ->
array_byte_size_max: Prims.nat ->
s: LowParse.Spec.Base.serializer p ->
elem_count_min: Prims.nat ->
elem_count_max: Prims.nat ->
i:
Prims.nat
{ LowParse.Spec.Array.vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true } ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i)
input)
(ensures
LowParse.Low.Base.Spec.gaccessor_post' (LowParse.Spec.Array.parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(LowParse.Low.Array.clens_vlarray_nth t elem_count_min elem_count_max i)
input
(LowParse.Low.Array.vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Array.vldata_vlarray_precond",
"LowParse.Bytes.bytes",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.Base.consumed_length",
"Prims._assert",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Array.parse_vlarray_kind",
"LowParse.Spec.Array.vlarray",
"LowParse.Spec.Array.parse_vlarray",
"LowParse.Low.Array.clens_vlarray_nth",
"LowParse.Low.Array.vlarray_nth_ghost''",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"FStar.Seq.Base.slice",
"LowParse.Bytes.byte",
"Prims.op_Multiply",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Seq.Base.length",
"Prims.op_Addition",
"LowParse.Low.Array.list_nth_constant_size_parser_correct",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.parse",
"LowParse.Spec.List.parse_list",
"FStar.Seq.Base.seq",
"FStar.UInt32.v",
"FStar.Pervasives.Native.option",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Array.parse_vlarray_eq_some",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Base.Spec.gaccessor_pre",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let vlarray_nth_ghost_correct'
(array_byte_size_min array_byte_size_max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(elem_count_min elem_count_max: nat)
(i:
nat
{ vldata_vlarray_precond array_byte_size_min
array_byte_size_max
p
elem_count_min
elem_count_max ==
true })
(input: bytes)
: Lemma
(requires
(gaccessor_pre (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input))
(ensures
(gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input))) =
| reveal_opaque (`%vlarray_nth_ghost'')
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input);
parse_vlarray_eq_some array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
()
input;
let sz = log256' array_byte_size_max in
let Some (len, _) = parse (parse_bounded_integer sz) input in
let input' = Seq.slice input (sz) (sz + U32.v len) in
assert (Some? (parse (parse_list p) input'));
list_nth_constant_size_parser_correct p input' i;
parse_strong_prefix p
(Seq.slice input' (i `Prims.op_Multiply` k.parser_kind_low) (Seq.length input'))
(Seq.slice input (sz + (i `Prims.op_Multiply` k.parser_kind_low)) (Seq.length input));
assert (gaccessor_post' (parse_vlarray array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
())
p
(clens_vlarray_nth t elem_count_min elem_count_max i)
input
(vlarray_nth_ghost'' array_byte_size_min
array_byte_size_max
s
elem_count_min
elem_count_max
i
input)) | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.get_bpp_cp_matrices | val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 85,
"start_col": 0,
"start_line": 82
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
mu_decode: Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) ->
seed_se: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a)
-> Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) *
Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Spec.Frodo.KEM.Decaps.get_bpp_cp_matrices_",
"FStar.Pervasives.Native.tuple3",
"Spec.Frodo.KEM.Encaps.get_sp_ep_epp_matrices"
] | [] | false | false | false | false | false | let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
| let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix =
get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix
in
bpp_matrix, cp_matrix | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_seed_se_k | val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a) | val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a) | let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 152,
"start_col": 0,
"start_line": 147
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
mu_decode: Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a)
-> Lib.ByteSequence.lbytes (2 * Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.frodo_shake",
"Prims.op_Addition",
"Spec.Frodo.Params.bytes_pkhash",
"FStar.Mul.op_Star",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Prims.l_and",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.unit",
"Spec.Frodo.Params.expand_crypto_secretkeybytes"
] | [] | false | false | false | false | false | let crypto_kem_dec_seed_se_k a mu_decode sk =
| expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.get_bp_c_matrices | val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 34,
"start_col": 0,
"start_line": 28
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a)
-> Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) *
Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"FStar.Pervasives.Native.Mktuple2",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Spec.Frodo.Pack.frodo_unpack",
"Spec.Frodo.Params.params_logq",
"Lib.IntTypes.U8",
"Spec.Frodo.Params.ct2bytes_len",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Spec.Frodo.Params.ct1bytes_len",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Prims.unit",
"Spec.Frodo.Params.expand_crypto_ciphertextbytes",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let get_bp_c_matrices a ct =
| expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s | val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)} | val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)} | let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 120,
"start_col": 0,
"start_line": 117
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)} | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
mu_decode: Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) ->
seed_se: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> mask:
Lib.IntTypes.uint16
{ Lib.IntTypes.v mask == 0 \/
Lib.IntTypes.v mask == Lib.IntTypes.v (Lib.IntTypes.ones Lib.IntTypes.U16 Lib.IntTypes.SEC)
} | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s_cond",
"Lib.IntTypes.uint16",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.range_t",
"Lib.IntTypes.ones",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.lseq",
"Prims.op_Multiply",
"Spec.Frodo.KEM.Decaps.get_bpp_cp_matrices"
] | [] | false | false | false | false | false | let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
| let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss0 | val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a) | val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a) | let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 138,
"start_col": 0,
"start_line": 131
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a) ->
mask:
Lib.IntTypes.uint16
{ Lib.IntTypes.v mask == 0 \/
Lib.IntTypes.v mask ==
Lib.IntTypes.v (Lib.IntTypes.ones Lib.IntTypes.U16 Lib.IntTypes.SEC) } ->
kp: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) ->
s: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a)
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Lib.IntTypes.uint16",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.IntTypes.range_t",
"Lib.IntTypes.ones",
"Spec.Frodo.Params.crypto_bytes",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Spec.Frodo.Params.frodo_shake",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.ByteSequence.seq_mask_select",
"Lib.IntTypes.to_u8",
"Prims.unit",
"Spec.Frodo.Lemmas.lemma_mask_cast"
] | [] | false | false | false | false | false | let crypto_kem_dec_ss0 a ct mask kp s =
| FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
let shake_input_ss = concat ct kp_s in
let ss =
frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a)
in
ss | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s_cond | val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0)) | val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0)) | let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2 | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 104,
"start_col": 0,
"start_line": 100
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0)) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
bpp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar ->
cp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Prims.Pure Lib.IntTypes.uint16 | Prims.Pure | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.unit",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.int_t",
"Spec.Matrix.matrix_eq",
"Lib.IntTypes.uint16"
] | [] | false | false | false | false | false | let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
| let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2 | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.frodo_mu_decode | val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 48,
"start_col": 0,
"start_line": 44
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
s_bytes: Lib.ByteSequence.lbytes (Spec.Frodo.Params.secretmatrixbytes_len a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.secretmatrixbytes_len",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.op_Multiply",
"Spec.Frodo.Params.params_extracted_bits",
"Spec.Frodo.Encode.frodo_key_decode",
"Spec.Frodo.Params.params_logq",
"Lib.IntTypes.U16",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"Spec.Matrix.mget",
"Lib.IntTypes.sub_mod",
"Spec.Matrix.mul_s",
"Spec.Matrix.sub",
"Spec.Matrix.matrix_from_lbytes",
"Spec.Frodo.Params.bytes_mu"
] | [] | false | false | false | false | false | let frodo_mu_decode a s_bytes bp_matrix c_matrix =
| let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_exponent_u32 | val check_exponent_u32:rsapss_check_exponent_st U32 | val check_exponent_u32:rsapss_check_exponent_st U32 | let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 145,
"start_col": 0,
"start_line": 144
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st Lib.IntTypes.U32 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent",
"Lib.IntTypes.U32",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u32"
] | [] | false | false | false | true | false | let check_exponent_u32:rsapss_check_exponent_st U32 =
| rsapss_check_exponent check_num_bits_u32 | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint32 | val mk_runtime_rsapss_checks_uint32: rsapss_checks U32 | val mk_runtime_rsapss_checks_uint32: rsapss_checks U32 | let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
} | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 154,
"start_col": 0,
"start_line": 150
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_checks Lib.IntTypes.U32 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.Mkrsapss_checks",
"Lib.IntTypes.U32",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u32",
"Hacl.Impl.RSAPSS.Keys.check_modulus_u32",
"Hacl.Impl.RSAPSS.Keys.check_exponent_u32"
] | [] | false | false | false | true | false | let mk_runtime_rsapss_checks_uint32 =
| {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32
} | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_modulus_u32 | val check_modulus_u32:rsapss_check_modulus_st U32 | val check_modulus_u32:rsapss_check_modulus_st U32 | let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 142,
"start_col": 0,
"start_line": 141
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st Lib.IntTypes.U32 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus",
"Lib.IntTypes.U32",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u32"
] | [] | false | false | false | true | false | let check_modulus_u32:rsapss_check_modulus_st U32 =
| rsapss_check_modulus check_num_bits_u32 | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ | val crypto_kem_dec_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | val crypto_kem_dec_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | let crypto_kem_dec_ a gen_a ct sk bp_matrix c_matrix =
let mu_decode = crypto_kem_dec_mu a sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix in
ss | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 218,
"start_col": 0,
"start_line": 215
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a)
let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k
val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss
val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix =
let seed_se_k = crypto_kem_dec_seed_se_k a mu_decode sk in
let ss = crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix in
ss
val crypto_kem_dec_mu:
a:frodo_alg
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let crypto_kem_dec_mu a sk bp_matrix c_matrix =
expand_crypto_secretkeybytes a;
let s_bytes = LSeq.sub sk (crypto_bytes a + crypto_publickeybytes a) (secretmatrixbytes_len a) in
let mu_decode = frodo_mu_decode a s_bytes bp_matrix c_matrix in
mu_decode
val crypto_kem_dec_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss2",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_mu"
] | [] | false | false | false | false | false | let crypto_kem_dec_ a gen_a ct sk bp_matrix c_matrix =
| let mu_decode = crypto_kem_dec_mu a sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix in
ss | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_num_bits_u32 | val check_num_bits_u32:bn_check_num_bits_st U32 | val check_num_bits_u32:bn_check_num_bits_st U32 | let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 139,
"start_col": 0,
"start_line": 138
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st Lib.IntTypes.U32 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits",
"Lib.IntTypes.U32"
] | [] | false | false | false | true | false | let check_num_bits_u32:bn_check_num_bits_st U32 =
| bn_check_num_bits | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_exponent_u64 | val check_exponent_u64:rsapss_check_exponent_st U64 | val check_exponent_u64:rsapss_check_exponent_st U64 | let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 164,
"start_col": 0,
"start_line": 163
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits
[@CInline]
let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st Lib.IntTypes.U64 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent",
"Lib.IntTypes.U64",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u64"
] | [] | false | false | false | true | false | let check_exponent_u64:rsapss_check_exponent_st U64 =
| rsapss_check_exponent check_num_bits_u64 | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_num_bits_u64 | val check_num_bits_u64:bn_check_num_bits_st U64 | val check_num_bits_u64:bn_check_num_bits_st U64 | let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 158,
"start_col": 0,
"start_line": 157
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st Lib.IntTypes.U64 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits",
"Lib.IntTypes.U64"
] | [] | false | false | false | true | false | let check_num_bits_u64:bn_check_num_bits_st U64 =
| bn_check_num_bits | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss2 | val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | let crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix =
let seed_se_k = crypto_kem_dec_seed_se_k a mu_decode sk in
let ss = crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix in
ss | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 189,
"start_col": 0,
"start_line": 186
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a)
let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k
val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss
val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
mu_decode: Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Frodo.Params.bytes_mu",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss1",
"Prims.op_Multiply",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_seed_se_k"
] | [] | false | false | false | false | false | let crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix =
| let seed_se_k = crypto_kem_dec_seed_se_k a mu_decode sk in
let ss = crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix in
ss | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint64 | val mk_runtime_rsapss_checks_uint64: rsapss_checks U64 | val mk_runtime_rsapss_checks_uint64: rsapss_checks U64 | let mk_runtime_rsapss_checks_uint64 = {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64;
} | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 173,
"start_col": 0,
"start_line": 169
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits
[@CInline]
let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64
[@CInline]
let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_checks Lib.IntTypes.U64 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.Mkrsapss_checks",
"Lib.IntTypes.U64",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u64",
"Hacl.Impl.RSAPSS.Keys.check_modulus_u64",
"Hacl.Impl.RSAPSS.Keys.check_exponent_u64"
] | [] | false | false | false | true | false | let mk_runtime_rsapss_checks_uint64 =
| {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64
} | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec | val crypto_kem_dec:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (crypto_bytes a) | val crypto_kem_dec:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (crypto_bytes a) | let crypto_kem_dec a gen_a ct sk =
let bp_matrix, c_matrix = get_bp_c_matrices a ct in
let ss = crypto_kem_dec_ a gen_a ct sk bp_matrix c_matrix in
ss | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 231,
"start_col": 0,
"start_line": 228
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a)
let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k
val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss
val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix =
let seed_se_k = crypto_kem_dec_seed_se_k a mu_decode sk in
let ss = crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix in
ss
val crypto_kem_dec_mu:
a:frodo_alg
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let crypto_kem_dec_mu a sk bp_matrix c_matrix =
expand_crypto_secretkeybytes a;
let s_bytes = LSeq.sub sk (crypto_bytes a + crypto_publickeybytes a) (secretmatrixbytes_len a) in
let mu_decode = frodo_mu_decode a s_bytes bp_matrix c_matrix in
mu_decode
val crypto_kem_dec_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ a gen_a ct sk bp_matrix c_matrix =
let mu_decode = crypto_kem_dec_mu a sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix in
ss
val crypto_kem_dec:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a)
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.U16",
"Prims.op_Multiply",
"Spec.Frodo.KEM.Decaps.get_bp_c_matrices"
] | [] | false | false | false | false | false | let crypto_kem_dec a gen_a ct sk =
| let bp_matrix, c_matrix = get_bp_c_matrices a ct in
let ss = crypto_kem_dec_ a gen_a ct sk bp_matrix c_matrix in
ss | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.check_modulus_u64 | val check_modulus_u64:rsapss_check_modulus_st U64 | val check_modulus_u64:rsapss_check_modulus_st U64 | let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 161,
"start_col": 0,
"start_line": 160
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st Lib.IntTypes.U64 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus",
"Lib.IntTypes.U64",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u64"
] | [] | false | false | false | true | false | let check_modulus_u64:rsapss_check_modulus_st U64 =
| rsapss_check_modulus check_num_bits_u64 | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_mu | val crypto_kem_dec_mu:
a:frodo_alg
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | val crypto_kem_dec_mu:
a:frodo_alg
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | let crypto_kem_dec_mu a sk bp_matrix c_matrix =
expand_crypto_secretkeybytes a;
let s_bytes = LSeq.sub sk (crypto_bytes a + crypto_publickeybytes a) (secretmatrixbytes_len a) in
let mu_decode = frodo_mu_decode a s_bytes bp_matrix c_matrix in
mu_decode | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 203,
"start_col": 0,
"start_line": 199
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a)
let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k
val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss
val crypto_kem_dec_ss2:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss2 a gen_a ct sk mu_decode bp_matrix c_matrix =
let seed_se_k = crypto_kem_dec_seed_se_k a mu_decode sk in
let ss = crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix in
ss
val crypto_kem_dec_mu:
a:frodo_alg
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.KEM.Decaps.frodo_mu_decode",
"Spec.Frodo.Params.secretmatrixbytes_len",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.crypto_publickeybytes",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Prims.unit",
"Spec.Frodo.Params.expand_crypto_secretkeybytes"
] | [] | false | false | false | false | false | let crypto_kem_dec_mu a sk bp_matrix c_matrix =
| expand_crypto_secretkeybytes a;
let s_bytes = LSeq.sub sk (crypto_bytes a + crypto_publickeybytes a) (secretmatrixbytes_len a) in
let mu_decode = frodo_mu_decode a s_bytes bp_matrix c_matrix in
mu_decode | false |
Spec.Frodo.KEM.Decaps.fst | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss1 | val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 173,
"start_col": 0,
"start_line": 166
} | module Spec.Frodo.KEM.Decaps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Params
open Spec.Frodo.KEM.Encaps
open Spec.Frodo.Encode
open Spec.Frodo.Pack
open Spec.Frodo.Sample
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module KG = Spec.Frodo.KEM.KeyGen
module FL = Spec.Frodo.Lemmas
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bp_c_matrices a ct =
expand_crypto_ciphertextbytes a;
let c1 = LSeq.sub ct 0 (ct1bytes_len a) in
let c2 = LSeq.sub ct (ct1bytes_len a) (ct2bytes_len a) in
let bp_matrix = frodo_unpack #params_nbar #(params_n a) (params_logq a) c1 in
let c_matrix = frodo_unpack #params_nbar #params_nbar (params_logq a) c2 in
bp_matrix, c_matrix
val frodo_mu_decode:
a:frodo_alg
-> s_bytes:lbytes (secretmatrixbytes_len a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (bytes_mu a)
let frodo_mu_decode a s_bytes bp_matrix c_matrix =
let s_matrix = matrix_from_lbytes (params_n a) params_nbar s_bytes in
let m_matrix = Matrix.sub c_matrix (Matrix.mul_s bp_matrix s_matrix) in
let mu_decode = frodo_key_decode (params_logq a) (params_extracted_bits a) params_nbar m_matrix in
mu_decode
val get_bpp_cp_matrices_:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> sk:lbytes (crypto_secretkeybytes a)
-> sp_matrix:matrix params_nbar (params_n a)
-> ep_matrix:matrix params_nbar (params_n a)
-> epp_matrix:matrix params_nbar params_nbar
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix =
let pk = LSeq.sub sk (crypto_bytes a) (crypto_publickeybytes a) in
let seed_a = LSeq.sub pk 0 bytes_seed_a in
let b = LSeq.sub pk bytes_seed_a (crypto_publickeybytes a - bytes_seed_a) in
let bpp_matrix = frodo_mul_add_sa_plus_e a gen_a seed_a sp_matrix ep_matrix in
let cp_matrix = frodo_mul_add_sb_plus_e_plus_mu a mu_decode b sp_matrix epp_matrix in
let bpp_matrix = mod_pow2 (params_logq a) bpp_matrix in
let cp_matrix = mod_pow2 (params_logq a) cp_matrix in
bpp_matrix, cp_matrix
val get_bpp_cp_matrices:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a) //mup
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar
let get_bpp_cp_matrices a gen_a mu_decode seed_se sk =
let sp_matrix, ep_matrix, epp_matrix = get_sp_ep_epp_matrices a seed_se in
let bpp_matrix, cp_matrix = get_bpp_cp_matrices_ a gen_a mu_decode sk sp_matrix ep_matrix epp_matrix in
bpp_matrix, cp_matrix
val crypto_kem_dec_kp_s_cond:
a:frodo_alg
-> bp_matrix:matrix params_nbar (params_n a)
-> bpp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> cp_matrix:matrix params_nbar params_nbar
-> Pure uint16
(requires True)
(ensures fun r ->
((bp_matrix == bpp_matrix /\ c_matrix == cp_matrix) ==> v r == v (ones U16 SEC)) /\
((bp_matrix =!= bpp_matrix \/ c_matrix =!= cp_matrix) ==> v r == 0))
let crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix =
let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2
val crypto_kem_dec_kp_s:
a:frodo_alg
-> gen_a:frodo_gen_a
-> mu_decode:lbytes (bytes_mu a)
-> seed_se:lbytes (crypto_bytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
let crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix =
let bpp_matrix, cp_matrix = get_bpp_cp_matrices a gen_a mu_decode seed_se sk in
let mask = crypto_kem_dec_kp_s_cond a bp_matrix bpp_matrix c_matrix cp_matrix in
mask
val crypto_kem_dec_ss0:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> mask:uint16{v mask == 0 \/ v mask == v (ones U16 SEC)}
-> kp:lbytes (crypto_bytes a)
-> s:lbytes (crypto_bytes a)
-> lbytes (crypto_bytes a)
let crypto_kem_dec_ss0 a ct mask kp s =
FL.lemma_mask_cast mask;
let kp_s = seq_mask_select kp s (to_u8 mask) in
//if v mask = v (ones U16 SEC) then kp else s in
let shake_input_ss = concat ct kp_s in
let ss = frodo_shake a (crypto_ciphertextbytes a + crypto_bytes a) shake_input_ss (crypto_bytes a) in
ss
val crypto_kem_dec_seed_se_k:
a:frodo_alg
-> mu_decode:lbytes (bytes_mu a)
-> sk:lbytes (crypto_secretkeybytes a)
-> lbytes (2 * crypto_bytes a)
let crypto_kem_dec_seed_se_k a mu_decode sk =
expand_crypto_secretkeybytes a;
let pkh = LSeq.sub sk (crypto_secretkeybytes a - bytes_pkhash a) (bytes_pkhash a) in
let pkh_mu_decode = concat pkh mu_decode in
let seed_se_k = frodo_shake a (bytes_pkhash a + bytes_mu a) pkh_mu_decode (2 * crypto_bytes a) in
seed_se_k
val crypto_kem_dec_ss1:
a:frodo_alg
-> gen_a:frodo_gen_a
-> ct:lbytes (crypto_ciphertextbytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> mu_decode:lbytes (bytes_mu a)
-> seed_se_k:lbytes (2 * crypto_bytes a)
-> bp_matrix:matrix params_nbar (params_n a)
-> c_matrix:matrix params_nbar params_nbar
-> lbytes (crypto_bytes a) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Pack.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"Spec.Frodo.KEM.Encaps.fst.checked",
"Spec.Frodo.Encode.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.KEM.Decaps.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "FL"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "KG"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Sample",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Pack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Encode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM.Encaps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a ->
ct: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_ciphertextbytes a) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
mu_decode: Lib.ByteSequence.lbytes (Spec.Frodo.Params.bytes_mu a) ->
seed_se_k: Lib.ByteSequence.lbytes (2 * Spec.Frodo.Params.crypto_bytes a) ->
bp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
c_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_bytes a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Frodo.Params.bytes_mu",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss0",
"Lib.IntTypes.U16",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.range",
"Lib.IntTypes.ones",
"Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Prims.op_Multiply"
] | [] | false | false | false | false | false | let crypto_kem_dec_ss1 a gen_a ct sk mu_decode seed_se_k bp_matrix c_matrix =
| let seed_se = LSeq.sub seed_se_k 0 (crypto_bytes a) in
let kp = LSeq.sub seed_se_k (crypto_bytes a) (crypto_bytes a) in
let s = LSeq.sub sk 0 (crypto_bytes a) in
let mask = crypto_kem_dec_kp_s a gen_a mu_decode seed_se sk bp_matrix c_matrix in
let ss = crypto_kem_dec_ss0 a ct mask kp s in
ss | false |
Test.Vectors.Chacha20Poly1305.fst | Test.Vectors.Chacha20Poly1305.input11 | val input11:(b: B.buffer UInt8.t {B.length b = 2011 /\ B.recallable b /\ B.disjoint b aad11}) | val input11:(b: B.buffer UInt8.t {B.length b = 2011 /\ B.recallable b /\ B.disjoint b aad11}) | let input11: (b: B.buffer UInt8.t { B.length b = 2011 /\ B.recallable b /\ B.disjoint b aad11 }) =
B.recall aad11;[@inline_let] let l = [ 0x74uy; 0xa6uy; 0x3euy; 0xe4uy; 0xb1uy; 0xcbuy; 0xafuy; 0xb0uy; 0x40uy; 0xe5uy; 0x0fuy; 0x9euy; 0xf1uy; 0xf2uy; 0x89uy; 0xb5uy; 0x42uy; 0x34uy; 0x8auy; 0xa1uy; 0x03uy; 0xb7uy; 0xe9uy; 0x57uy; 0x46uy; 0xbeuy; 0x20uy; 0xe4uy; 0x6euy; 0xb0uy; 0xebuy; 0xffuy; 0xeauy; 0x07uy; 0x7euy; 0xefuy; 0xe2uy; 0x55uy; 0x9fuy; 0xe5uy; 0x78uy; 0x3auy; 0xb7uy; 0x83uy; 0xc2uy; 0x18uy; 0x40uy; 0x7buy; 0xebuy; 0xcduy; 0x81uy; 0xfbuy; 0x90uy; 0x12uy; 0x9euy; 0x46uy; 0xa9uy; 0xd6uy; 0x4auy; 0xbauy; 0xb0uy; 0x62uy; 0xdbuy; 0x6buy; 0x99uy; 0xc4uy; 0xdbuy; 0x54uy; 0x4buy; 0xb8uy; 0xa5uy; 0x71uy; 0xcbuy; 0xcduy; 0x63uy; 0x32uy; 0x55uy; 0xfbuy; 0x31uy; 0xf0uy; 0x38uy; 0xf5uy; 0xbeuy; 0x78uy; 0xe4uy; 0x45uy; 0xceuy; 0x1buy; 0x6auy; 0x5buy; 0x0euy; 0xf4uy; 0x16uy; 0xe4uy; 0xb1uy; 0x3duy; 0xf6uy; 0x63uy; 0x7buy; 0xa7uy; 0x0cuy; 0xdeuy; 0x6fuy; 0x8fuy; 0x74uy; 0xdfuy; 0xe0uy; 0x1euy; 0x9duy; 0xceuy; 0x8fuy; 0x24uy; 0xefuy; 0x23uy; 0x35uy; 0x33uy; 0x7buy; 0x83uy; 0x34uy; 0x23uy; 0x58uy; 0x74uy; 0x14uy; 0x77uy; 0x1fuy; 0xc2uy; 0x4fuy; 0x4euy; 0xc6uy; 0x89uy; 0xf9uy; 0x52uy; 0x09uy; 0x37uy; 0x64uy; 0x14uy; 0xc4uy; 0x01uy; 0x6buy; 0x9duy; 0x77uy; 0xe8uy; 0x90uy; 0x5duy; 0xa8uy; 0x4auy; 0x2auy; 0xefuy; 0x5cuy; 0x7fuy; 0xebuy; 0xbbuy; 0xb2uy; 0xc6uy; 0x93uy; 0x99uy; 0x66uy; 0xdcuy; 0x7fuy; 0xd4uy; 0x9euy; 0x2auy; 0xcauy; 0x8duy; 0xdbuy; 0xe7uy; 0x20uy; 0xcfuy; 0xe4uy; 0x73uy; 0xaeuy; 0x49uy; 0x7duy; 0x64uy; 0x0fuy; 0x0euy; 0x28uy; 0x46uy; 0xa9uy; 0xa8uy; 0x32uy; 0xe4uy; 0x0euy; 0xf6uy; 0x51uy; 0x53uy; 0xb8uy; 0x3cuy; 0xb1uy; 0xffuy; 0xa3uy; 0x33uy; 0x41uy; 0x75uy; 0xffuy; 0xf1uy; 0x6fuy; 0xf1uy; 0xfbuy; 0xbbuy; 0x83uy; 0x7fuy; 0x06uy; 0x9buy; 0xe7uy; 0x1buy; 0x0auy; 0xe0uy; 0x5cuy; 0x33uy; 0x60uy; 0x5buy; 0xdbuy; 0x5buy; 0xeduy; 0xfeuy; 0xa5uy; 0x16uy; 0x19uy; 0x72uy; 0xa3uy; 0x64uy; 0x23uy; 0x00uy; 0x02uy; 0xc7uy; 0xf3uy; 0x6auy; 0x81uy; 0x3euy; 0x44uy; 0x1duy; 0x79uy; 0x15uy; 0x5fuy; 0x9auy; 0xdeuy; 0xe2uy; 0xfduy; 0x1buy; 0x73uy; 0xc1uy; 0xbcuy; 0x23uy; 0xbauy; 0x31uy; 0xd2uy; 0x50uy; 0xd5uy; 0xaduy; 0x7fuy; 0x74uy; 0xa7uy; 0xc9uy; 0xf8uy; 0x3euy; 0x2buy; 0x26uy; 0x10uy; 0xf6uy; 0x03uy; 0x36uy; 0x74uy; 0xe4uy; 0x0euy; 0x6auy; 0x72uy; 0xb7uy; 0x73uy; 0x0auy; 0x42uy; 0x28uy; 0xc2uy; 0xaduy; 0x5euy; 0x03uy; 0xbeuy; 0xb8uy; 0x0buy; 0xa8uy; 0x5buy; 0xd4uy; 0xb8uy; 0xbauy; 0x52uy; 0x89uy; 0xb1uy; 0x9buy; 0xc1uy; 0xc3uy; 0x65uy; 0x87uy; 0xeduy; 0xa5uy; 0xf4uy; 0x86uy; 0xfduy; 0x41uy; 0x80uy; 0x91uy; 0x27uy; 0x59uy; 0x53uy; 0x67uy; 0x15uy; 0x78uy; 0x54uy; 0x8buy; 0x2duy; 0x3duy; 0xc7uy; 0xffuy; 0x02uy; 0x92uy; 0x07uy; 0x5fuy; 0x7auy; 0x4buy; 0x60uy; 0x59uy; 0x3cuy; 0x6fuy; 0x5cuy; 0xd8uy; 0xecuy; 0x95uy; 0xd2uy; 0xfeuy; 0xa0uy; 0x3buy; 0xd8uy; 0x3fuy; 0xd1uy; 0x69uy; 0xa6uy; 0xd6uy; 0x41uy; 0xb2uy; 0xf4uy; 0x4duy; 0x12uy; 0xf4uy; 0x58uy; 0x3euy; 0x66uy; 0x64uy; 0x80uy; 0x31uy; 0x9buy; 0xa8uy; 0x4cuy; 0x8buy; 0x07uy; 0xb2uy; 0xecuy; 0x66uy; 0x94uy; 0x66uy; 0x47uy; 0x50uy; 0x50uy; 0x5fuy; 0x18uy; 0x0buy; 0x0euy; 0xd6uy; 0xc0uy; 0x39uy; 0x21uy; 0x13uy; 0x9euy; 0x33uy; 0xbcuy; 0x79uy; 0x36uy; 0x02uy; 0x96uy; 0x70uy; 0xf0uy; 0x48uy; 0x67uy; 0x2fuy; 0x26uy; 0xe9uy; 0x6duy; 0x10uy; 0xbbuy; 0xd6uy; 0x3fuy; 0xd1uy; 0x64uy; 0x7auy; 0x2euy; 0xbeuy; 0x0cuy; 0x61uy; 0xf0uy; 0x75uy; 0x42uy; 0x38uy; 0x23uy; 0xb1uy; 0x9euy; 0x9fuy; 0x7cuy; 0x67uy; 0x66uy; 0xd9uy; 0x58uy; 0x9auy; 0xf1uy; 0xbbuy; 0x41uy; 0x2auy; 0x8duy; 0x65uy; 0x84uy; 0x94uy; 0xfcuy; 0xdcuy; 0x6auy; 0x50uy; 0x64uy; 0xdbuy; 0x56uy; 0x33uy; 0x76uy; 0x00uy; 0x10uy; 0xeduy; 0xbeuy; 0xd2uy; 0x12uy; 0xf6uy; 0xf6uy; 0x1buy; 0xa2uy; 0x16uy; 0xdeuy; 0xaeuy; 0x31uy; 0x95uy; 0xdduy; 0xb1uy; 0x08uy; 0x7euy; 0x4euy; 0xeeuy; 0xe7uy; 0xf9uy; 0xa5uy; 0xfbuy; 0x5buy; 0x61uy; 0x43uy; 0x00uy; 0x40uy; 0xf6uy; 0x7euy; 0x02uy; 0x04uy; 0x32uy; 0x4euy; 0x0cuy; 0xe2uy; 0x66uy; 0x0duy; 0xd7uy; 0x07uy; 0x98uy; 0x0euy; 0xf8uy; 0x72uy; 0x34uy; 0x6duy; 0x95uy; 0x86uy; 0xd7uy; 0xcbuy; 0x31uy; 0x54uy; 0x47uy; 0xd0uy; 0x38uy; 0x29uy; 0x9cuy; 0x5auy; 0x68uy; 0xd4uy; 0x87uy; 0x76uy; 0xc9uy; 0xe7uy; 0x7euy; 0xe3uy; 0xf4uy; 0x81uy; 0x6duy; 0x18uy; 0xcbuy; 0xc9uy; 0x05uy; 0xafuy; 0xa0uy; 0xfbuy; 0x66uy; 0xf7uy; 0xf1uy; 0x1cuy; 0xc6uy; 0x14uy; 0x11uy; 0x4fuy; 0x2buy; 0x79uy; 0x42uy; 0x8buy; 0xbcuy; 0xacuy; 0xe7uy; 0x6cuy; 0xfeuy; 0x0fuy; 0x58uy; 0xe7uy; 0x7cuy; 0x78uy; 0x39uy; 0x30uy; 0xb0uy; 0x66uy; 0x2cuy; 0x9buy; 0x6duy; 0x3auy; 0xe1uy; 0xcfuy; 0xc9uy; 0xa4uy; 0x0euy; 0x6duy; 0x6duy; 0x8auy; 0xa1uy; 0x3auy; 0xe7uy; 0x28uy; 0xd4uy; 0x78uy; 0x4cuy; 0xa6uy; 0xa2uy; 0x2auy; 0xa6uy; 0x03uy; 0x30uy; 0xd7uy; 0xa8uy; 0x25uy; 0x66uy; 0x87uy; 0x2fuy; 0x69uy; 0x5cuy; 0x4euy; 0xdduy; 0xa5uy; 0x49uy; 0x5duy; 0x37uy; 0x4auy; 0x59uy; 0xc4uy; 0xafuy; 0x1fuy; 0xa2uy; 0xe4uy; 0xf8uy; 0xa6uy; 0x12uy; 0x97uy; 0xd5uy; 0x79uy; 0xf5uy; 0xe2uy; 0x4auy; 0x2buy; 0x5fuy; 0x61uy; 0xe4uy; 0x9euy; 0xe3uy; 0xeeuy; 0xb8uy; 0xa7uy; 0x5buy; 0x2fuy; 0xf4uy; 0x9euy; 0x6cuy; 0xfbuy; 0xd1uy; 0xc6uy; 0x56uy; 0x77uy; 0xbauy; 0x75uy; 0xaauy; 0x3duy; 0x1auy; 0xa8uy; 0x0buy; 0xb3uy; 0x68uy; 0x24uy; 0x00uy; 0x10uy; 0x7fuy; 0xfduy; 0xd7uy; 0xa1uy; 0x8duy; 0x83uy; 0x54uy; 0x4fuy; 0x1fuy; 0xd8uy; 0x2auy; 0xbeuy; 0x8auy; 0x0cuy; 0x87uy; 0xabuy; 0xa2uy; 0xdeuy; 0xc3uy; 0x39uy; 0xbfuy; 0x09uy; 0x03uy; 0xa5uy; 0xf3uy; 0x05uy; 0x28uy; 0xe1uy; 0xe1uy; 0xeeuy; 0x39uy; 0x70uy; 0x9cuy; 0xd8uy; 0x81uy; 0x12uy; 0x1euy; 0x02uy; 0x40uy; 0xd2uy; 0x6euy; 0xf0uy; 0xebuy; 0x1buy; 0x3duy; 0x22uy; 0xc6uy; 0xe5uy; 0xe3uy; 0xb4uy; 0x5auy; 0x98uy; 0xbbuy; 0xf0uy; 0x22uy; 0x28uy; 0x8duy; 0xe5uy; 0xd3uy; 0x16uy; 0x48uy; 0x24uy; 0xa5uy; 0xe6uy; 0x66uy; 0x0cuy; 0xf9uy; 0x08uy; 0xf9uy; 0x7euy; 0x1euy; 0xe1uy; 0x28uy; 0x26uy; 0x22uy; 0xc7uy; 0xc7uy; 0x0auy; 0x32uy; 0x47uy; 0xfauy; 0xa3uy; 0xbeuy; 0x3cuy; 0xc4uy; 0xc5uy; 0x53uy; 0x0auy; 0xd5uy; 0x94uy; 0x4auy; 0xd7uy; 0x93uy; 0xd8uy; 0x42uy; 0x99uy; 0xb9uy; 0x0auy; 0xdbuy; 0x56uy; 0xf7uy; 0xb9uy; 0x1cuy; 0x53uy; 0x4fuy; 0xfauy; 0xd3uy; 0x74uy; 0xaduy; 0xd9uy; 0x68uy; 0xf1uy; 0x1buy; 0xdfuy; 0x61uy; 0xc6uy; 0x5euy; 0xa8uy; 0x48uy; 0xfcuy; 0xd4uy; 0x4auy; 0x4cuy; 0x3cuy; 0x32uy; 0xf7uy; 0x1cuy; 0x96uy; 0x21uy; 0x9buy; 0xf9uy; 0xa3uy; 0xccuy; 0x5auy; 0xceuy; 0xd5uy; 0xd7uy; 0x08uy; 0x24uy; 0xf6uy; 0x1cuy; 0xfduy; 0xdduy; 0x38uy; 0xc2uy; 0x32uy; 0xe9uy; 0xb8uy; 0xe7uy; 0xb6uy; 0xfauy; 0x9duy; 0x45uy; 0x13uy; 0x2cuy; 0x83uy; 0xfduy; 0x4auy; 0x69uy; 0x82uy; 0xcduy; 0xdcuy; 0xb3uy; 0x76uy; 0x0cuy; 0x9euy; 0xd8uy; 0xf4uy; 0x1buy; 0x45uy; 0x15uy; 0xb4uy; 0x97uy; 0xe7uy; 0x58uy; 0x34uy; 0xe2uy; 0x03uy; 0x29uy; 0x5auy; 0xbfuy; 0xb6uy; 0xe0uy; 0x5duy; 0x13uy; 0xd9uy; 0x2buy; 0xb4uy; 0x80uy; 0xb2uy; 0x45uy; 0x81uy; 0x6auy; 0x2euy; 0x6cuy; 0x89uy; 0x7duy; 0xeeuy; 0xbbuy; 0x52uy; 0xdduy; 0x1fuy; 0x18uy; 0xe7uy; 0x13uy; 0x6buy; 0x33uy; 0x0euy; 0xeauy; 0x36uy; 0x92uy; 0x77uy; 0x7buy; 0x6duy; 0x9cuy; 0x5auy; 0x5fuy; 0x45uy; 0x7buy; 0x7buy; 0x35uy; 0x62uy; 0x23uy; 0xd1uy; 0xbfuy; 0x0fuy; 0xd0uy; 0x08uy; 0x1buy; 0x2buy; 0x80uy; 0x6buy; 0x7euy; 0xf1uy; 0x21uy; 0x47uy; 0xb0uy; 0x57uy; 0xd1uy; 0x98uy; 0x72uy; 0x90uy; 0x34uy; 0x1cuy; 0x20uy; 0x04uy; 0xffuy; 0x3duy; 0x5cuy; 0xeeuy; 0x0euy; 0x57uy; 0x5fuy; 0x6fuy; 0x24uy; 0x4euy; 0x3cuy; 0xeauy; 0xfcuy; 0xa5uy; 0xa9uy; 0x83uy; 0xc9uy; 0x61uy; 0xb4uy; 0x51uy; 0x24uy; 0xf8uy; 0x27uy; 0x5euy; 0x46uy; 0x8cuy; 0xb1uy; 0x53uy; 0x02uy; 0x96uy; 0x35uy; 0xbauy; 0xb8uy; 0x4cuy; 0x71uy; 0xd3uy; 0x15uy; 0x59uy; 0x35uy; 0x22uy; 0x20uy; 0xaduy; 0x03uy; 0x9fuy; 0x66uy; 0x44uy; 0x3buy; 0x9cuy; 0x35uy; 0x37uy; 0x1fuy; 0x9buy; 0xbbuy; 0xf3uy; 0xdbuy; 0x35uy; 0x63uy; 0x30uy; 0x64uy; 0xaauy; 0xa2uy; 0x06uy; 0xa8uy; 0x5duy; 0xbbuy; 0xe1uy; 0x9fuy; 0x70uy; 0xecuy; 0x82uy; 0x11uy; 0x06uy; 0x36uy; 0xecuy; 0x8buy; 0x69uy; 0x66uy; 0x24uy; 0x44uy; 0xc9uy; 0x4auy; 0x57uy; 0xbbuy; 0x9buy; 0x78uy; 0x13uy; 0xceuy; 0x9cuy; 0x0cuy; 0xbauy; 0x92uy; 0x93uy; 0x63uy; 0xb8uy; 0xe2uy; 0x95uy; 0x0fuy; 0x0fuy; 0x16uy; 0x39uy; 0x52uy; 0xfduy; 0x3auy; 0x6duy; 0x02uy; 0x4buy; 0xdfuy; 0x13uy; 0xd3uy; 0x2auy; 0x22uy; 0xb4uy; 0x03uy; 0x7cuy; 0x54uy; 0x49uy; 0x96uy; 0x68uy; 0x54uy; 0x10uy; 0xfauy; 0xefuy; 0xaauy; 0x6cuy; 0xe8uy; 0x22uy; 0xdcuy; 0x71uy; 0x16uy; 0x13uy; 0x1auy; 0xf6uy; 0x28uy; 0xe5uy; 0x6duy; 0x77uy; 0x3duy; 0xcduy; 0x30uy; 0x63uy; 0xb1uy; 0x70uy; 0x52uy; 0xa1uy; 0xc5uy; 0x94uy; 0x5fuy; 0xcfuy; 0xe8uy; 0xb8uy; 0x26uy; 0x98uy; 0xf7uy; 0x06uy; 0xa0uy; 0x0auy; 0x70uy; 0xfauy; 0x03uy; 0x80uy; 0xacuy; 0xc1uy; 0xecuy; 0xd6uy; 0x4cuy; 0x54uy; 0xd7uy; 0xfeuy; 0x47uy; 0xb6uy; 0x88uy; 0x4auy; 0xf7uy; 0x71uy; 0x24uy; 0xeeuy; 0xf3uy; 0xd2uy; 0xc2uy; 0x4auy; 0x7fuy; 0xfeuy; 0x61uy; 0xc7uy; 0x35uy; 0xc9uy; 0x37uy; 0x67uy; 0xcbuy; 0x24uy; 0x35uy; 0xdauy; 0x7euy; 0xcauy; 0x5fuy; 0xf3uy; 0x8duy; 0xd4uy; 0x13uy; 0x8euy; 0xd6uy; 0xcbuy; 0x4duy; 0x53uy; 0x8fuy; 0x53uy; 0x1fuy; 0xc0uy; 0x74uy; 0xf7uy; 0x53uy; 0xb9uy; 0x5euy; 0x23uy; 0x37uy; 0xbauy; 0x6euy; 0xe3uy; 0x9duy; 0x07uy; 0x55uy; 0x25uy; 0x7buy; 0xe6uy; 0x2auy; 0x64uy; 0xd1uy; 0x32uy; 0xdduy; 0x54uy; 0x1buy; 0x4buy; 0xc0uy; 0xe1uy; 0xd7uy; 0x69uy; 0x58uy; 0xf8uy; 0x93uy; 0x29uy; 0xc4uy; 0xdduy; 0x23uy; 0x2fuy; 0xa5uy; 0xfcuy; 0x9duy; 0x7euy; 0xf8uy; 0xd4uy; 0x90uy; 0xcduy; 0x82uy; 0x55uy; 0xdcuy; 0x16uy; 0x16uy; 0x9fuy; 0x07uy; 0x52uy; 0x9buy; 0x9duy; 0x25uy; 0xeduy; 0x32uy; 0xc5uy; 0x7buy; 0xdfuy; 0xf6uy; 0x83uy; 0x46uy; 0x3duy; 0x65uy; 0xb7uy; 0xefuy; 0x87uy; 0x7auy; 0x12uy; 0x69uy; 0x8fuy; 0x06uy; 0x7cuy; 0x51uy; 0x15uy; 0x4auy; 0x08uy; 0xe8uy; 0xacuy; 0x9auy; 0x0cuy; 0x24uy; 0xa7uy; 0x27uy; 0xd8uy; 0x46uy; 0x2fuy; 0xe7uy; 0x01uy; 0x0euy; 0x1cuy; 0xc6uy; 0x91uy; 0xb0uy; 0x6euy; 0x85uy; 0x65uy; 0xf0uy; 0x29uy; 0x0duy; 0x2euy; 0x6buy; 0x3buy; 0xfbuy; 0x4buy; 0xdfuy; 0xe4uy; 0x80uy; 0x93uy; 0x03uy; 0x66uy; 0x46uy; 0x3euy; 0x8auy; 0x6euy; 0xf3uy; 0x5euy; 0x4duy; 0x62uy; 0x0euy; 0x49uy; 0x05uy; 0xafuy; 0xd4uy; 0xf8uy; 0x21uy; 0x20uy; 0x61uy; 0x1duy; 0x39uy; 0x17uy; 0xf4uy; 0x61uy; 0x47uy; 0x95uy; 0xfbuy; 0x15uy; 0x2euy; 0xb3uy; 0x4fuy; 0xd0uy; 0x5duy; 0xf5uy; 0x7duy; 0x40uy; 0xdauy; 0x90uy; 0x3cuy; 0x6buy; 0xcbuy; 0x17uy; 0x00uy; 0x13uy; 0x3buy; 0x64uy; 0x34uy; 0x1buy; 0xf0uy; 0xf2uy; 0xe5uy; 0x3buy; 0xb2uy; 0xc7uy; 0xd3uy; 0x5fuy; 0x3auy; 0x44uy; 0xa6uy; 0x9buy; 0xb7uy; 0x78uy; 0x0euy; 0x42uy; 0x5duy; 0x4cuy; 0xc1uy; 0xe9uy; 0xd2uy; 0xcbuy; 0xb7uy; 0x78uy; 0xd1uy; 0xfeuy; 0x9auy; 0xb5uy; 0x07uy; 0xe9uy; 0xe0uy; 0xbeuy; 0xe2uy; 0x8auy; 0xa7uy; 0x01uy; 0x83uy; 0x00uy; 0x8cuy; 0x5cuy; 0x08uy; 0xe6uy; 0x63uy; 0x12uy; 0x92uy; 0xb7uy; 0xb7uy; 0xa6uy; 0x19uy; 0x7duy; 0x38uy; 0x13uy; 0x38uy; 0x92uy; 0x87uy; 0x24uy; 0xf9uy; 0x48uy; 0xb3uy; 0x5euy; 0x87uy; 0x6auy; 0x40uy; 0x39uy; 0x5cuy; 0x3fuy; 0xeduy; 0x8fuy; 0xeeuy; 0xdbuy; 0x15uy; 0x82uy; 0x06uy; 0xdauy; 0x49uy; 0x21uy; 0x2buy; 0xb5uy; 0xbfuy; 0x32uy; 0x7cuy; 0x9fuy; 0x42uy; 0x28uy; 0x63uy; 0xcfuy; 0xafuy; 0x1euy; 0xf8uy; 0xc6uy; 0xa0uy; 0xd1uy; 0x02uy; 0x43uy; 0x57uy; 0x62uy; 0xecuy; 0x9buy; 0x0fuy; 0x01uy; 0x9euy; 0x71uy; 0xd8uy; 0x87uy; 0x9duy; 0x01uy; 0xc1uy; 0x58uy; 0x77uy; 0xd9uy; 0xafuy; 0xb1uy; 0x10uy; 0x7euy; 0xdduy; 0xa6uy; 0x50uy; 0x96uy; 0xe5uy; 0xf0uy; 0x72uy; 0x00uy; 0x6duy; 0x4buy; 0xf8uy; 0x2auy; 0x8fuy; 0x19uy; 0xf3uy; 0x22uy; 0x88uy; 0x11uy; 0x4auy; 0x8buy; 0x7cuy; 0xfduy; 0xb7uy; 0xeduy; 0xe1uy; 0xf6uy; 0x40uy; 0x39uy; 0xe0uy; 0xe9uy; 0xf6uy; 0x3duy; 0x25uy; 0xe6uy; 0x74uy; 0x3cuy; 0x58uy; 0x57uy; 0x7fuy; 0xe1uy; 0x22uy; 0x96uy; 0x47uy; 0x31uy; 0x91uy; 0xbauy; 0x70uy; 0x85uy; 0x28uy; 0x6buy; 0x9fuy; 0x6euy; 0x25uy; 0xacuy; 0x23uy; 0x66uy; 0x2fuy; 0x29uy; 0x88uy; 0x28uy; 0xceuy; 0x8cuy; 0x5cuy; 0x88uy; 0x53uy; 0xd1uy; 0x3buy; 0xccuy; 0x6auy; 0x51uy; 0xb2uy; 0xe1uy; 0x28uy; 0x3fuy; 0x91uy; 0xb4uy; 0x0duy; 0x00uy; 0x3auy; 0xe3uy; 0xf8uy; 0xc3uy; 0x8fuy; 0xd7uy; 0x96uy; 0x62uy; 0x0euy; 0x2euy; 0xfcuy; 0xc8uy; 0x6cuy; 0x77uy; 0xa6uy; 0x1duy; 0x22uy; 0xc1uy; 0xb8uy; 0xe6uy; 0x61uy; 0xd7uy; 0x67uy; 0x36uy; 0x13uy; 0x7buy; 0xbbuy; 0x9buy; 0x59uy; 0x09uy; 0xa6uy; 0xdfuy; 0xf7uy; 0x6buy; 0xa3uy; 0x40uy; 0x1auy; 0xf5uy; 0x4fuy; 0xb4uy; 0xdauy; 0xd3uy; 0xf3uy; 0x81uy; 0x93uy; 0xc6uy; 0x18uy; 0xd9uy; 0x26uy; 0xeeuy; 0xacuy; 0xf0uy; 0xaauy; 0xdfuy; 0xc5uy; 0x9cuy; 0xcauy; 0xc2uy; 0xa2uy; 0xccuy; 0x7buy; 0x5cuy; 0x24uy; 0xb0uy; 0xbcuy; 0xd0uy; 0x6auy; 0x4duy; 0x89uy; 0x09uy; 0xb8uy; 0x07uy; 0xfeuy; 0x87uy; 0xaduy; 0x0auy; 0xeauy; 0xb8uy; 0x42uy; 0xf9uy; 0x5euy; 0xb3uy; 0x3euy; 0x36uy; 0x4cuy; 0xafuy; 0x75uy; 0x9euy; 0x1cuy; 0xebuy; 0xbduy; 0xbcuy; 0xbbuy; 0x80uy; 0x40uy; 0xa7uy; 0x3auy; 0x30uy; 0xbfuy; 0xa8uy; 0x44uy; 0xf4uy; 0xebuy; 0x38uy; 0xaduy; 0x29uy; 0xbauy; 0x23uy; 0xeduy; 0x41uy; 0x0cuy; 0xeauy; 0xd2uy; 0xbbuy; 0x41uy; 0x18uy; 0xd6uy; 0xb9uy; 0xbauy; 0x65uy; 0x2buy; 0xa3uy; 0x91uy; 0x6duy; 0x1fuy; 0xa9uy; 0xf4uy; 0xd1uy; 0x25uy; 0x8duy; 0x4duy; 0x38uy; 0xffuy; 0x64uy; 0xa0uy; 0xecuy; 0xdeuy; 0xa6uy; 0xb6uy; 0x79uy; 0xabuy; 0x8euy; 0x33uy; 0x6cuy; 0x47uy; 0xdeuy; 0xafuy; 0x94uy; 0xa4uy; 0xa5uy; 0x86uy; 0x77uy; 0x55uy; 0x09uy; 0x92uy; 0x81uy; 0x31uy; 0x76uy; 0xc7uy; 0x34uy; 0x22uy; 0x89uy; 0x8euy; 0x3duy; 0x26uy; 0x26uy; 0xd7uy; 0xfcuy; 0x1euy; 0x16uy; 0x72uy; 0x13uy; 0x33uy; 0x63uy; 0xd5uy; 0x22uy; 0xbeuy; 0xb8uy; 0x04uy; 0x34uy; 0x84uy; 0x41uy; 0xbbuy; 0x80uy; 0xd0uy; 0x9fuy; 0x46uy; 0x48uy; 0x07uy; 0xa7uy; 0xfcuy; 0x2buy; 0x3auy; 0x75uy; 0x55uy; 0x8cuy; 0xc7uy; 0x6auy; 0xbduy; 0x7euy; 0x46uy; 0x08uy; 0x84uy; 0x0fuy; 0xd5uy; 0x74uy; 0xc0uy; 0x82uy; 0x8euy; 0xaauy; 0x61uy; 0x05uy; 0x01uy; 0xb2uy; 0x47uy; 0x6euy; 0x20uy; 0x6auy; 0x2duy; 0x58uy; 0x70uy; 0x48uy; 0x32uy; 0xa7uy; 0x37uy; 0xd2uy; 0xb8uy; 0x82uy; 0x1auy; 0x51uy; 0xb9uy; 0x61uy; 0xdduy; 0xfduy; 0x9duy; 0x6buy; 0x0euy; 0x18uy; 0x97uy; 0xf8uy; 0x45uy; 0x5fuy; 0x87uy; 0x10uy; 0xcfuy; 0x34uy; 0x72uy; 0x45uy; 0x26uy; 0x49uy; 0x70uy; 0xe7uy; 0xa3uy; 0x78uy; 0xe0uy; 0x52uy; 0x89uy; 0x84uy; 0x94uy; 0x83uy; 0x82uy; 0xc2uy; 0x69uy; 0x8fuy; 0xe3uy; 0xe1uy; 0x3fuy; 0x60uy; 0x74uy; 0x88uy; 0xc4uy; 0xf7uy; 0x75uy; 0x2cuy; 0xfbuy; 0xbduy; 0xb6uy; 0xc4uy; 0x7euy; 0x10uy; 0x0auy; 0x6cuy; 0x90uy; 0x04uy; 0x9euy; 0xc3uy; 0x3fuy; 0x59uy; 0x7cuy; 0xceuy; 0x31uy; 0x18uy; 0x60uy; 0x57uy; 0x73uy; 0x46uy; 0x94uy; 0x7duy; 0x06uy; 0xa0uy; 0x6duy; 0x44uy; 0xecuy; 0xa2uy; 0x0auy; 0x9euy; 0x05uy; 0x15uy; 0xefuy; 0xcauy; 0x5cuy; 0xbfuy; 0x00uy; 0xebuy; 0xf7uy; 0x3duy; 0x32uy; 0xd4uy; 0xa5uy; 0xefuy; 0x49uy; 0x89uy; 0x5euy; 0x46uy; 0xb0uy; 0xa6uy; 0x63uy; 0x5buy; 0x8auy; 0x73uy; 0xaeuy; 0x6fuy; 0xd5uy; 0x9duy; 0xf8uy; 0x4fuy; 0x40uy; 0xb5uy; 0xb2uy; 0x6euy; 0xd3uy; 0xb6uy; 0x01uy; 0xa9uy; 0x26uy; 0xa2uy; 0x21uy; 0xcfuy; 0x33uy; 0x7auy; 0x3auy; 0xa4uy; 0x23uy; 0x13uy; 0xb0uy; 0x69uy; 0x6auy; 0xeeuy; 0xceuy; 0xd8uy; 0x9duy; 0x01uy; 0x1duy; 0x50uy; 0xc1uy; 0x30uy; 0x6cuy; 0xb1uy; 0xcduy; 0xa0uy; 0xf0uy; 0xf0uy; 0xa2uy; 0x64uy; 0x6fuy; 0xbbuy; 0xbfuy; 0x5euy; 0xe6uy; 0xabuy; 0x87uy; 0xb4uy; 0x0fuy; 0x4fuy; 0x15uy; 0xafuy; 0xb5uy; 0x25uy; 0xa1uy; 0xb2uy; 0xd0uy; 0x80uy; 0x2cuy; 0xfbuy; 0xf9uy; 0xfeuy; 0xd2uy; 0x33uy; 0xbbuy; 0x76uy; 0xfeuy; 0x7cuy; 0xa8uy; 0x66uy; 0xf7uy; 0xe7uy; 0x85uy; 0x9fuy; 0x1fuy; 0x85uy; 0x57uy; 0x88uy; 0xe1uy; 0xe9uy; 0x63uy; 0xe4uy; 0xd8uy; 0x1cuy; 0xa1uy; 0xfbuy; 0xdauy; 0x44uy; 0x05uy; 0x2euy; 0x1duy; 0x3auy; 0x1cuy; 0xffuy; 0xc8uy; 0x3buy; 0xc0uy; 0xfeuy; 0xdauy; 0x22uy; 0x0buy; 0x43uy; 0xd6uy; 0x88uy; 0x39uy; 0x4cuy; 0x4auy; 0xa6uy; 0x69uy; 0x18uy; 0x93uy; 0x42uy; 0x4euy; 0xb5uy; 0xccuy; 0x66uy; 0x0duy; 0x09uy; 0xf8uy; 0x1euy; 0x7cuy; 0xd3uy; 0x3cuy; 0x99uy; 0x0duy; 0x50uy; 0x1duy; 0x62uy; 0xe9uy; 0x57uy; 0x06uy; 0xbfuy; 0x19uy; 0x88uy; 0xdduy; 0xaduy; 0x7buy; 0x4fuy; 0xf9uy; 0xc7uy; 0x82uy; 0x6duy; 0x8duy; 0xc8uy; 0xc4uy; 0xc5uy; 0x78uy; 0x17uy; 0x20uy; 0x15uy; 0xc5uy; 0x52uy; 0x41uy; 0xcfuy; 0x5buy; 0xd6uy; 0x7fuy; 0x94uy; 0x02uy; 0x41uy; 0xe0uy; 0x40uy; 0x22uy; 0x03uy; 0x5euy; 0xd1uy; 0x53uy; 0xd4uy; 0x86uy; 0xd3uy; 0x2cuy; 0x9fuy; 0x0fuy; 0x96uy; 0xe3uy; 0x6buy; 0x9auy; 0x76uy; 0x32uy; 0x06uy; 0x47uy; 0x4buy; 0x11uy; 0xb3uy; 0xdduy; 0x03uy; 0x65uy; 0xbduy; 0x9buy; 0x01uy; 0xdauy; 0x9cuy; 0xb9uy; 0x7euy; 0x3fuy; 0x6auy; 0xc4uy; 0x7buy; 0xeauy; 0xd4uy; 0x3cuy; 0xb9uy; 0xfbuy; 0x5cuy; 0x6buy; 0x64uy; 0x33uy; 0x52uy; 0xbauy; 0x64uy; 0x78uy; 0x8fuy; 0xa4uy; 0xafuy; 0x7auy; 0x61uy; 0x8duy; 0xbcuy; 0xc5uy; 0x73uy; 0xe9uy; 0x6buy; 0x58uy; 0x97uy; 0x4buy; 0xbfuy; 0x63uy; 0x22uy; 0xd3uy; 0x37uy; 0x02uy; 0x54uy; 0xc5uy; 0xb9uy; 0x16uy; 0x4auy; 0xf0uy; 0x19uy; 0xd8uy; 0x94uy; 0x57uy; 0xb8uy; 0x8auy; 0xb3uy; 0x16uy; 0x3buy; 0xd0uy; 0x84uy; 0x8euy; 0x67uy; 0xa6uy; 0xa3uy; 0x7duy; 0x78uy; 0xecuy; 0x00uy; ] in
assert_norm (List.Tot.length l = 2011);
B.gcmalloc_of_list HyperStack.root l | {
"file_name": "providers/test/vectors/Test.Vectors.Chacha20Poly1305.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 474,
"start_col": 0,
"start_line": 471
} | module Test.Vectors.Chacha20Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x1cuy; 0x92uy; 0x40uy; 0xa5uy; 0xebuy; 0x55uy; 0xd3uy; 0x8auy; 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x04uy; 0xf6uy; 0xb5uy; 0xf0uy; 0x47uy; 0x39uy; 0x17uy; 0xc1uy; 0x40uy; 0x2buy; 0x80uy; 0x09uy; 0x9duy; 0xcauy; 0x5cuy; 0xbcuy; 0x20uy; 0x70uy; 0x75uy; 0xc0uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let nonce0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce0_len: (x:UInt32.t { UInt32.v x = B.length nonce0 }) =
12ul
let aad0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x4euy; 0x91uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad0_len: (x:UInt32.t { UInt32.v x = B.length aad0 }) =
12ul
let input0: (b: B.buffer UInt8.t { B.length b = 265 /\ B.recallable b /\ B.disjoint b aad0 }) =
B.recall aad0;[@inline_let] let l = [ 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x72uy; 0x65uy; 0x20uy; 0x64uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x76uy; 0x61uy; 0x6cuy; 0x69uy; 0x64uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x61uy; 0x20uy; 0x6duy; 0x61uy; 0x78uy; 0x69uy; 0x6duy; 0x75uy; 0x6duy; 0x20uy; 0x6fuy; 0x66uy; 0x20uy; 0x73uy; 0x69uy; 0x78uy; 0x20uy; 0x6duy; 0x6fuy; 0x6euy; 0x74uy; 0x68uy; 0x73uy; 0x20uy; 0x61uy; 0x6euy; 0x64uy; 0x20uy; 0x6duy; 0x61uy; 0x79uy; 0x20uy; 0x62uy; 0x65uy; 0x20uy; 0x75uy; 0x70uy; 0x64uy; 0x61uy; 0x74uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x72uy; 0x65uy; 0x70uy; 0x6cuy; 0x61uy; 0x63uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x6fuy; 0x62uy; 0x73uy; 0x6fuy; 0x6cuy; 0x65uy; 0x74uy; 0x65uy; 0x64uy; 0x20uy; 0x62uy; 0x79uy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x74uy; 0x20uy; 0x61uy; 0x6euy; 0x79uy; 0x20uy; 0x74uy; 0x69uy; 0x6duy; 0x65uy; 0x2euy; 0x20uy; 0x49uy; 0x74uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x6euy; 0x61uy; 0x70uy; 0x70uy; 0x72uy; 0x6fuy; 0x70uy; 0x72uy; 0x69uy; 0x61uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x75uy; 0x73uy; 0x65uy; 0x20uy; 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x72uy; 0x65uy; 0x66uy; 0x65uy; 0x72uy; 0x65uy; 0x6euy; 0x63uy; 0x65uy; 0x20uy; 0x6duy; 0x61uy; 0x74uy; 0x65uy; 0x72uy; 0x69uy; 0x61uy; 0x6cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x63uy; 0x69uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x68uy; 0x65uy; 0x6duy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x74uy; 0x68uy; 0x61uy; 0x6euy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x2fuy; 0xe2uy; 0x80uy; 0x9cuy; 0x77uy; 0x6fuy; 0x72uy; 0x6buy; 0x20uy; 0x69uy; 0x6euy; 0x20uy; 0x70uy; 0x72uy; 0x6fuy; 0x67uy; 0x72uy; 0x65uy; 0x73uy; 0x73uy; 0x2euy; 0x2fuy; 0xe2uy; 0x80uy; 0x9duy; ] in
assert_norm (List.Tot.length l = 265);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
265ul
let output0: (b: B.buffer UInt8.t { B.length b = 281 /\ B.recallable b }) =
[@inline_let] let l = [ 0x64uy; 0xa0uy; 0x86uy; 0x15uy; 0x75uy; 0x86uy; 0x1auy; 0xf4uy; 0x60uy; 0xf0uy; 0x62uy; 0xc7uy; 0x9buy; 0xe6uy; 0x43uy; 0xbduy; 0x5euy; 0x80uy; 0x5cuy; 0xfduy; 0x34uy; 0x5cuy; 0xf3uy; 0x89uy; 0xf1uy; 0x08uy; 0x67uy; 0x0auy; 0xc7uy; 0x6cuy; 0x8cuy; 0xb2uy; 0x4cuy; 0x6cuy; 0xfcuy; 0x18uy; 0x75uy; 0x5duy; 0x43uy; 0xeeuy; 0xa0uy; 0x9euy; 0xe9uy; 0x4euy; 0x38uy; 0x2duy; 0x26uy; 0xb0uy; 0xbduy; 0xb7uy; 0xb7uy; 0x3cuy; 0x32uy; 0x1buy; 0x01uy; 0x00uy; 0xd4uy; 0xf0uy; 0x3buy; 0x7fuy; 0x35uy; 0x58uy; 0x94uy; 0xcfuy; 0x33uy; 0x2fuy; 0x83uy; 0x0euy; 0x71uy; 0x0buy; 0x97uy; 0xceuy; 0x98uy; 0xc8uy; 0xa8uy; 0x4auy; 0xbduy; 0x0buy; 0x94uy; 0x81uy; 0x14uy; 0xaduy; 0x17uy; 0x6euy; 0x00uy; 0x8duy; 0x33uy; 0xbduy; 0x60uy; 0xf9uy; 0x82uy; 0xb1uy; 0xffuy; 0x37uy; 0xc8uy; 0x55uy; 0x97uy; 0x97uy; 0xa0uy; 0x6euy; 0xf4uy; 0xf0uy; 0xefuy; 0x61uy; 0xc1uy; 0x86uy; 0x32uy; 0x4euy; 0x2buy; 0x35uy; 0x06uy; 0x38uy; 0x36uy; 0x06uy; 0x90uy; 0x7buy; 0x6auy; 0x7cuy; 0x02uy; 0xb0uy; 0xf9uy; 0xf6uy; 0x15uy; 0x7buy; 0x53uy; 0xc8uy; 0x67uy; 0xe4uy; 0xb9uy; 0x16uy; 0x6cuy; 0x76uy; 0x7buy; 0x80uy; 0x4duy; 0x46uy; 0xa5uy; 0x9buy; 0x52uy; 0x16uy; 0xcduy; 0xe7uy; 0xa4uy; 0xe9uy; 0x90uy; 0x40uy; 0xc5uy; 0xa4uy; 0x04uy; 0x33uy; 0x22uy; 0x5euy; 0xe2uy; 0x82uy; 0xa1uy; 0xb0uy; 0xa0uy; 0x6cuy; 0x52uy; 0x3euy; 0xafuy; 0x45uy; 0x34uy; 0xd7uy; 0xf8uy; 0x3fuy; 0xa1uy; 0x15uy; 0x5buy; 0x00uy; 0x47uy; 0x71uy; 0x8cuy; 0xbcuy; 0x54uy; 0x6auy; 0x0duy; 0x07uy; 0x2buy; 0x04uy; 0xb3uy; 0x56uy; 0x4euy; 0xeauy; 0x1buy; 0x42uy; 0x22uy; 0x73uy; 0xf5uy; 0x48uy; 0x27uy; 0x1auy; 0x0buy; 0xb2uy; 0x31uy; 0x60uy; 0x53uy; 0xfauy; 0x76uy; 0x99uy; 0x19uy; 0x55uy; 0xebuy; 0xd6uy; 0x31uy; 0x59uy; 0x43uy; 0x4euy; 0xceuy; 0xbbuy; 0x4euy; 0x46uy; 0x6duy; 0xaeuy; 0x5auy; 0x10uy; 0x73uy; 0xa6uy; 0x72uy; 0x76uy; 0x27uy; 0x09uy; 0x7auy; 0x10uy; 0x49uy; 0xe6uy; 0x17uy; 0xd9uy; 0x1duy; 0x36uy; 0x10uy; 0x94uy; 0xfauy; 0x68uy; 0xf0uy; 0xffuy; 0x77uy; 0x98uy; 0x71uy; 0x30uy; 0x30uy; 0x5buy; 0xeauy; 0xbauy; 0x2euy; 0xdauy; 0x04uy; 0xdfuy; 0x99uy; 0x7buy; 0x71uy; 0x4duy; 0x6cuy; 0x6fuy; 0x2cuy; 0x29uy; 0xa6uy; 0xaduy; 0x5cuy; 0xb4uy; 0x02uy; 0x2buy; 0x02uy; 0x70uy; 0x9buy; 0xeeuy; 0xaduy; 0x9duy; 0x67uy; 0x89uy; 0x0cuy; 0xbbuy; 0x22uy; 0x39uy; 0x23uy; 0x36uy; 0xfeuy; 0xa1uy; 0x85uy; 0x1fuy; 0x38uy; ] in
assert_norm (List.Tot.length l = 281);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output0_len: (x:UInt32.t { UInt32.v x = B.length output0 }) =
281ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4cuy; 0xf5uy; 0x96uy; 0x83uy; 0x38uy; 0xe6uy; 0xaeuy; 0x7fuy; 0x2duy; 0x29uy; 0x25uy; 0x76uy; 0xd5uy; 0x75uy; 0x27uy; 0x86uy; 0x91uy; 0x9auy; 0x27uy; 0x7auy; 0xfbuy; 0x46uy; 0xc5uy; 0xefuy; 0x94uy; 0x81uy; 0x79uy; 0x57uy; 0x14uy; 0x59uy; 0x40uy; 0x68uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let nonce1: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcauy; 0xbfuy; 0x33uy; 0x71uy; 0x32uy; 0x45uy; 0x77uy; 0x8euy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce1_len: (x:UInt32.t { UInt32.v x = B.length nonce1 }) =
12ul
let aad1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad1_len: (x:UInt32.t { UInt32.v x = B.length aad1 }) =
0ul
let input1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad1 }) =
B.recall aad1;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
0ul
let output1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeauy; 0xe0uy; 0x1euy; 0x9euy; 0x2cuy; 0x91uy; 0xaauy; 0xe1uy; 0xdbuy; 0x5duy; 0x99uy; 0x3fuy; 0x8auy; 0xf7uy; 0x69uy; 0x92uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output1_len: (x:UInt32.t { UInt32.v x = B.length output1 }) =
16ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0xb0uy; 0x5duy; 0x40uy; 0xc8uy; 0xeduy; 0x44uy; 0x88uy; 0x34uy; 0xd1uy; 0x13uy; 0xafuy; 0x57uy; 0xa1uy; 0xebuy; 0x3auy; 0x2auy; 0x80uy; 0x51uy; 0x36uy; 0xecuy; 0x5buy; 0xbcuy; 0x08uy; 0x93uy; 0x84uy; 0x21uy; 0xb5uy; 0x13uy; 0x88uy; 0x3cuy; 0x0duy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let nonce2: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x3duy; 0x86uy; 0xb5uy; 0x6buy; 0xc8uy; 0xa3uy; 0x1fuy; 0x1duy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce2_len: (x:UInt32.t { UInt32.v x = B.length nonce2 }) =
12ul
let aad2: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x10uy; 0x41uy; 0x12uy; 0x1fuy; 0xf3uy; 0xd2uy; 0x6buy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad2_len: (x:UInt32.t { UInt32.v x = B.length aad2 }) =
8ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad2 }) =
B.recall aad2;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let output2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x6buy; 0x3buy; 0x82uy; 0xceuy; 0x5auy; 0xbduy; 0xd6uy; 0xa9uy; 0x35uy; 0x83uy; 0xd8uy; 0x8cuy; 0x3duy; 0x85uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output2_len: (x:UInt32.t { UInt32.v x = B.length output2 }) =
16ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4buy; 0x28uy; 0x4buy; 0xa3uy; 0x7buy; 0xbeuy; 0xe9uy; 0xf8uy; 0x31uy; 0x80uy; 0x82uy; 0xd7uy; 0xd8uy; 0xe8uy; 0xb5uy; 0xa1uy; 0xe2uy; 0x18uy; 0x18uy; 0x8auy; 0x9cuy; 0xfauy; 0xa3uy; 0x3duy; 0x25uy; 0x71uy; 0x3euy; 0x40uy; 0xbcuy; 0x54uy; 0x7auy; 0x3euy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let nonce3: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xd2uy; 0x32uy; 0x1fuy; 0x29uy; 0x28uy; 0xc6uy; 0xc4uy; 0xc4uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce3_len: (x:UInt32.t { UInt32.v x = B.length nonce3 }) =
12ul
let aad3: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x6auy; 0xe2uy; 0xaduy; 0x3fuy; 0x88uy; 0x39uy; 0x5auy; 0x40uy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad3_len: (x:UInt32.t { UInt32.v x = B.length aad3 }) =
8ul
let input3: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad3 }) =
B.recall aad3;[@inline_let] let l = [ 0xa4uy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
1ul
let output3: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb7uy; 0x1buy; 0xb0uy; 0x73uy; 0x59uy; 0xb0uy; 0x84uy; 0xb2uy; 0x6duy; 0x8euy; 0xabuy; 0x94uy; 0x31uy; 0xa1uy; 0xaeuy; 0xacuy; 0x89uy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output3_len: (x:UInt32.t { UInt32.v x = B.length output3 }) =
17ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0xcauy; 0x9cuy; 0x23uy; 0x2auy; 0x4buy; 0x4buy; 0x31uy; 0x0euy; 0x92uy; 0x89uy; 0x8buy; 0xf4uy; 0x93uy; 0xc7uy; 0x87uy; 0x98uy; 0xa3uy; 0xd8uy; 0x39uy; 0xf8uy; 0xf4uy; 0xa7uy; 0x01uy; 0xc0uy; 0x2euy; 0x0auy; 0xa6uy; 0x7euy; 0x5auy; 0x78uy; 0x87uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let nonce4: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x1cuy; 0xaauy; 0x5fuy; 0x9cuy; 0xbfuy; 0x92uy; 0x30uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce4_len: (x:UInt32.t { UInt32.v x = B.length nonce4 }) =
12ul
let aad4: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad4_len: (x:UInt32.t { UInt32.v x = B.length aad4 }) =
0ul
let input4: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad4 }) =
B.recall aad4;[@inline_let] let l = [ 0x2duy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
1ul
let output4: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbfuy; 0xe1uy; 0x5buy; 0x0buy; 0xdbuy; 0x6buy; 0xf5uy; 0x5euy; 0x6cuy; 0x5duy; 0x84uy; 0x44uy; 0x39uy; 0x81uy; 0xc1uy; 0x9cuy; 0xacuy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output4_len: (x:UInt32.t { UInt32.v x = B.length output4 }) =
17ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x68uy; 0x7buy; 0x8duy; 0x8euy; 0xe3uy; 0xc4uy; 0xdduy; 0xaeuy; 0xdfuy; 0x72uy; 0x7fuy; 0x53uy; 0x72uy; 0x25uy; 0x1euy; 0x78uy; 0x91uy; 0xcbuy; 0x69uy; 0x76uy; 0x1fuy; 0x49uy; 0x93uy; 0xf9uy; 0x6fuy; 0x21uy; 0xccuy; 0x39uy; 0x9cuy; 0xaduy; 0xb1uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let nonce5: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdfuy; 0x51uy; 0x84uy; 0x82uy; 0x42uy; 0x0cuy; 0x75uy; 0x9cuy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce5_len: (x:UInt32.t { UInt32.v x = B.length nonce5 }) =
12ul
let aad5: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) =
[@inline_let] let l = [ 0x70uy; 0xd3uy; 0x33uy; 0xf3uy; 0x8buy; 0x18uy; 0x0buy; ] in
assert_norm (List.Tot.length l = 7);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad5_len: (x:UInt32.t { UInt32.v x = B.length aad5 }) =
7ul
let input5: (b: B.buffer UInt8.t { B.length b = 129 /\ B.recallable b /\ B.disjoint b aad5 }) =
B.recall aad5;[@inline_let] let l = [ 0x33uy; 0x2fuy; 0x94uy; 0xc1uy; 0xa4uy; 0xefuy; 0xccuy; 0x2auy; 0x5buy; 0xa6uy; 0xe5uy; 0x8fuy; 0x1duy; 0x40uy; 0xf0uy; 0x92uy; 0x3cuy; 0xd9uy; 0x24uy; 0x11uy; 0xa9uy; 0x71uy; 0xf9uy; 0x37uy; 0x14uy; 0x99uy; 0xfauy; 0xbeuy; 0xe6uy; 0x80uy; 0xdeuy; 0x50uy; 0xc9uy; 0x96uy; 0xd4uy; 0xb0uy; 0xecuy; 0x9euy; 0x17uy; 0xecuy; 0xd2uy; 0x5euy; 0x72uy; 0x99uy; 0xfcuy; 0x0auy; 0xe1uy; 0xcbuy; 0x48uy; 0xd2uy; 0x85uy; 0xdduy; 0x2fuy; 0x90uy; 0xe0uy; 0x66uy; 0x3buy; 0xe6uy; 0x20uy; 0x74uy; 0xbeuy; 0x23uy; 0x8fuy; 0xcbuy; 0xb4uy; 0xe4uy; 0xdauy; 0x48uy; 0x40uy; 0xa6uy; 0xd1uy; 0x1buy; 0xc7uy; 0x42uy; 0xceuy; 0x2fuy; 0x0cuy; 0xa6uy; 0x85uy; 0x6euy; 0x87uy; 0x37uy; 0x03uy; 0xb1uy; 0x7cuy; 0x25uy; 0x96uy; 0xa3uy; 0x05uy; 0xd8uy; 0xb0uy; 0xf4uy; 0xeduy; 0xeauy; 0xc2uy; 0xf0uy; 0x31uy; 0x98uy; 0x6cuy; 0xd1uy; 0x14uy; 0x25uy; 0xc0uy; 0xcbuy; 0x01uy; 0x74uy; 0xd0uy; 0x82uy; 0xf4uy; 0x36uy; 0xf5uy; 0x41uy; 0xd5uy; 0xdcuy; 0xcauy; 0xc5uy; 0xbbuy; 0x98uy; 0xfeuy; 0xfcuy; 0x69uy; 0x21uy; 0x70uy; 0xd8uy; 0xa4uy; 0x4buy; 0xc8uy; 0xdeuy; 0x8fuy; ] in
assert_norm (List.Tot.length l = 129);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
129ul
let output5: (b: B.buffer UInt8.t { B.length b = 145 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8buy; 0x06uy; 0xd3uy; 0x31uy; 0xb0uy; 0x93uy; 0x45uy; 0xb1uy; 0x75uy; 0x6euy; 0x26uy; 0xf9uy; 0x67uy; 0xbcuy; 0x90uy; 0x15uy; 0x81uy; 0x2cuy; 0xb5uy; 0xf0uy; 0xc6uy; 0x2buy; 0xc7uy; 0x8cuy; 0x56uy; 0xd1uy; 0xbfuy; 0x69uy; 0x6cuy; 0x07uy; 0xa0uy; 0xdauy; 0x65uy; 0x27uy; 0xc9uy; 0x90uy; 0x3duy; 0xefuy; 0x4buy; 0x11uy; 0x0fuy; 0x19uy; 0x07uy; 0xfduy; 0x29uy; 0x92uy; 0xd9uy; 0xc8uy; 0xf7uy; 0x99uy; 0x2euy; 0x4auy; 0xd0uy; 0xb8uy; 0x2cuy; 0xdcuy; 0x93uy; 0xf5uy; 0x9euy; 0x33uy; 0x78uy; 0xd1uy; 0x37uy; 0xc3uy; 0x66uy; 0xd7uy; 0x5euy; 0xbcuy; 0x44uy; 0xbfuy; 0x53uy; 0xa5uy; 0xbcuy; 0xc4uy; 0xcbuy; 0x7buy; 0x3auy; 0x8euy; 0x7fuy; 0x02uy; 0xbduy; 0xbbuy; 0xe7uy; 0xcauy; 0xa6uy; 0x6cuy; 0x6buy; 0x93uy; 0x21uy; 0x93uy; 0x10uy; 0x61uy; 0xe7uy; 0x69uy; 0xd0uy; 0x78uy; 0xf3uy; 0x07uy; 0x5auy; 0x1auy; 0x8fuy; 0x73uy; 0xaauy; 0xb1uy; 0x4euy; 0xd3uy; 0xdauy; 0x4fuy; 0xf3uy; 0x32uy; 0xe1uy; 0x66uy; 0x3euy; 0x6cuy; 0xc6uy; 0x13uy; 0xbauy; 0x06uy; 0x5buy; 0xfcuy; 0x6auy; 0xe5uy; 0x6fuy; 0x60uy; 0xfbuy; 0x07uy; 0x40uy; 0xb0uy; 0x8cuy; 0x9duy; 0x84uy; 0x43uy; 0x6buy; 0xc1uy; 0xf7uy; 0x8duy; 0x8duy; 0x31uy; 0xf7uy; 0x7auy; 0x39uy; 0x4duy; 0x8fuy; 0x9auy; 0xebuy; ] in
assert_norm (List.Tot.length l = 145);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output5_len: (x:UInt32.t { UInt32.v x = B.length output5 }) =
145ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8duy; 0xb8uy; 0x91uy; 0x48uy; 0xf0uy; 0xe7uy; 0x0auy; 0xbduy; 0xf9uy; 0x3fuy; 0xcduy; 0xd9uy; 0xa0uy; 0x1euy; 0x42uy; 0x4cuy; 0xe7uy; 0xdeuy; 0x25uy; 0x3duy; 0xa3uy; 0xd7uy; 0x05uy; 0x80uy; 0x8duy; 0xf2uy; 0x82uy; 0xacuy; 0x44uy; 0x16uy; 0x51uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let nonce6: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdeuy; 0x7buy; 0xefuy; 0xc3uy; 0x65uy; 0x1buy; 0x68uy; 0xb0uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce6_len: (x:UInt32.t { UInt32.v x = B.length nonce6 }) =
12ul
let aad6: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad6_len: (x:UInt32.t { UInt32.v x = B.length aad6 }) =
0ul
let input6: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b /\ B.disjoint b aad6 }) =
B.recall aad6;[@inline_let] let l = [ 0x9buy; 0x18uy; 0xdbuy; 0xdduy; 0x9auy; 0x0fuy; 0x3euy; 0xa5uy; 0x15uy; 0x17uy; 0xdeuy; 0xdfuy; 0x08uy; 0x9duy; 0x65uy; 0x0auy; 0x67uy; 0x30uy; 0x12uy; 0xe2uy; 0x34uy; 0x77uy; 0x4buy; 0xc1uy; 0xd9uy; 0xc6uy; 0x1fuy; 0xabuy; 0xc6uy; 0x18uy; 0x50uy; 0x17uy; 0xa7uy; 0x9duy; 0x3cuy; 0xa6uy; 0xc5uy; 0x35uy; 0x8cuy; 0x1cuy; 0xc0uy; 0xa1uy; 0x7cuy; 0x9fuy; 0x03uy; 0x89uy; 0xcauy; 0xe1uy; 0xe6uy; 0xe9uy; 0xd4uy; 0xd3uy; 0x88uy; 0xdbuy; 0xb4uy; 0x51uy; 0x9duy; 0xecuy; 0xb4uy; 0xfcuy; 0x52uy; 0xeeuy; 0x6duy; 0xf1uy; 0x75uy; 0x42uy; 0xc6uy; 0xfduy; 0xbduy; 0x7auy; 0x8euy; 0x86uy; 0xfcuy; 0x44uy; 0xb3uy; 0x4fuy; 0xf3uy; 0xeauy; 0x67uy; 0x5auy; 0x41uy; 0x13uy; 0xbauy; 0xb0uy; 0xdcuy; 0xe1uy; 0xd3uy; 0x2auy; 0x7cuy; 0x22uy; 0xb3uy; 0xcauy; 0xacuy; 0x6auy; 0x37uy; 0x98uy; 0x3euy; 0x1duy; 0x40uy; 0x97uy; 0xf7uy; 0x9buy; 0x1duy; 0x36uy; 0x6buy; 0xb3uy; 0x28uy; 0xbduy; 0x60uy; 0x82uy; 0x47uy; 0x34uy; 0xaauy; 0x2fuy; 0x7duy; 0xe9uy; 0xa8uy; 0x70uy; 0x81uy; 0x57uy; 0xd4uy; 0xb9uy; 0x77uy; 0x0auy; 0x9duy; 0x29uy; 0xa7uy; 0x84uy; 0x52uy; 0x4fuy; 0xc2uy; 0x4auy; 0x40uy; 0x3buy; 0x3cuy; 0xd4uy; 0xc9uy; 0x2auy; 0xdbuy; 0x4auy; 0x53uy; 0xc4uy; 0xbeuy; 0x80uy; 0xe9uy; 0x51uy; 0x7fuy; 0x8fuy; 0xc7uy; 0xa2uy; 0xceuy; 0x82uy; 0x5cuy; 0x91uy; 0x1euy; 0x74uy; 0xd9uy; 0xd0uy; 0xbduy; 0xd5uy; 0xf3uy; 0xfduy; 0xdauy; 0x4duy; 0x25uy; 0xb4uy; 0xbbuy; 0x2duy; 0xacuy; 0x2fuy; 0x3duy; 0x71uy; 0x85uy; 0x7buy; 0xcfuy; 0x3cuy; 0x7buy; 0x3euy; 0x0euy; 0x22uy; 0x78uy; 0x0cuy; 0x29uy; 0xbfuy; 0xe4uy; 0xf4uy; 0x57uy; 0xb3uy; 0xcbuy; 0x49uy; 0xa0uy; 0xfcuy; 0x1euy; 0x05uy; 0x4euy; 0x16uy; 0xbcuy; 0xd5uy; 0xa8uy; 0xa3uy; 0xeeuy; 0x05uy; 0x35uy; 0xc6uy; 0x7cuy; 0xabuy; 0x60uy; 0x14uy; 0x55uy; 0x1auy; 0x8euy; 0xc5uy; 0x88uy; 0x5duy; 0xd5uy; 0x81uy; 0xc2uy; 0x81uy; 0xa5uy; 0xc4uy; 0x60uy; 0xdbuy; 0xafuy; 0x77uy; 0x91uy; 0xe1uy; 0xceuy; 0xa2uy; 0x7euy; 0x7fuy; 0x42uy; 0xe3uy; 0xb0uy; 0x13uy; 0x1cuy; 0x1fuy; 0x25uy; 0x60uy; 0x21uy; 0xe2uy; 0x40uy; 0x5fuy; 0x99uy; 0xb7uy; 0x73uy; 0xecuy; 0x9buy; 0x2buy; 0xf0uy; 0x65uy; 0x11uy; 0xc8uy; 0xd0uy; 0x0auy; 0x9fuy; 0xd3uy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
256ul
let output6: (b: B.buffer UInt8.t { B.length b = 272 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x04uy; 0xc2uy; 0xeduy; 0x8duy; 0xfduy; 0x97uy; 0x5cuy; 0xd2uy; 0xb7uy; 0xe2uy; 0xc1uy; 0x6buy; 0xa3uy; 0xbauy; 0xf8uy; 0xc9uy; 0x50uy; 0xc3uy; 0xc6uy; 0xa5uy; 0xe3uy; 0xa4uy; 0x7cuy; 0xc3uy; 0x23uy; 0x49uy; 0x5euy; 0xa9uy; 0xb9uy; 0x32uy; 0xebuy; 0x8auy; 0x7cuy; 0xcauy; 0xe5uy; 0xecuy; 0xfbuy; 0x7cuy; 0xc0uy; 0xcbuy; 0x7duy; 0xdcuy; 0x2cuy; 0x9duy; 0x92uy; 0x55uy; 0x21uy; 0x0auy; 0xc8uy; 0x43uy; 0x63uy; 0x59uy; 0x0auy; 0x31uy; 0x70uy; 0x82uy; 0x67uy; 0x41uy; 0x03uy; 0xf8uy; 0xdfuy; 0xf2uy; 0xacuy; 0xa7uy; 0x02uy; 0xd4uy; 0xd5uy; 0x8auy; 0x2duy; 0xc8uy; 0x99uy; 0x19uy; 0x66uy; 0xd0uy; 0xf6uy; 0x88uy; 0x2cuy; 0x77uy; 0xd9uy; 0xd4uy; 0x0duy; 0x6cuy; 0xbduy; 0x98uy; 0xdeuy; 0xe7uy; 0x7fuy; 0xaduy; 0x7euy; 0x8auy; 0xfbuy; 0xe9uy; 0x4buy; 0xe5uy; 0xf7uy; 0xe5uy; 0x50uy; 0xa0uy; 0x90uy; 0x3fuy; 0xd6uy; 0x22uy; 0x53uy; 0xe3uy; 0xfeuy; 0x1buy; 0xccuy; 0x79uy; 0x3buy; 0xecuy; 0x12uy; 0x47uy; 0x52uy; 0xa7uy; 0xd6uy; 0x04uy; 0xe3uy; 0x52uy; 0xe6uy; 0x93uy; 0x90uy; 0x91uy; 0x32uy; 0x73uy; 0x79uy; 0xb8uy; 0xd0uy; 0x31uy; 0xdeuy; 0x1fuy; 0x9fuy; 0x2fuy; 0x05uy; 0x38uy; 0x54uy; 0x2fuy; 0x35uy; 0x04uy; 0x39uy; 0xe0uy; 0xa7uy; 0xbauy; 0xc6uy; 0x52uy; 0xf6uy; 0x37uy; 0x65uy; 0x4cuy; 0x07uy; 0xa9uy; 0x7euy; 0xb3uy; 0x21uy; 0x6fuy; 0x74uy; 0x8cuy; 0xc9uy; 0xdeuy; 0xdbuy; 0x65uy; 0x1buy; 0x9buy; 0xaauy; 0x60uy; 0xb1uy; 0x03uy; 0x30uy; 0x6buy; 0xb2uy; 0x03uy; 0xc4uy; 0x1cuy; 0x04uy; 0xf8uy; 0x0fuy; 0x64uy; 0xafuy; 0x46uy; 0xe4uy; 0x65uy; 0x99uy; 0x49uy; 0xe2uy; 0xeauy; 0xceuy; 0x78uy; 0x00uy; 0xd8uy; 0x8buy; 0xd5uy; 0x2euy; 0xcfuy; 0xfcuy; 0x40uy; 0x49uy; 0xe8uy; 0x58uy; 0xdcuy; 0x34uy; 0x9cuy; 0x8cuy; 0x61uy; 0xbfuy; 0x0auy; 0x8euy; 0xecuy; 0x39uy; 0xa9uy; 0x30uy; 0x05uy; 0x5auy; 0xd2uy; 0x56uy; 0x01uy; 0xc7uy; 0xdauy; 0x8fuy; 0x4euy; 0xbbuy; 0x43uy; 0xa3uy; 0x3auy; 0xf9uy; 0x15uy; 0x2auy; 0xd0uy; 0xa0uy; 0x7auy; 0x87uy; 0x34uy; 0x82uy; 0xfeuy; 0x8auy; 0xd1uy; 0x2duy; 0x5euy; 0xc7uy; 0xbfuy; 0x04uy; 0x53uy; 0x5fuy; 0x3buy; 0x36uy; 0xd4uy; 0x25uy; 0x5cuy; 0x34uy; 0x7auy; 0x8duy; 0xd5uy; 0x05uy; 0xceuy; 0x72uy; 0xcauy; 0xefuy; 0x7auy; 0x4buy; 0xbcuy; 0xb0uy; 0x10uy; 0x5cuy; 0x96uy; 0x42uy; 0x3auy; 0x00uy; 0x98uy; 0xcduy; 0x15uy; 0xe8uy; 0xb7uy; 0x53uy; ] in
assert_norm (List.Tot.length l = 272);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output6_len: (x:UInt32.t { UInt32.v x = B.length output6 }) =
272ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0xaauy; 0x4fuy; 0x99uy; 0xfduy; 0x3euy; 0xa8uy; 0x53uy; 0xc1uy; 0x44uy; 0xe9uy; 0x81uy; 0x18uy; 0xdcuy; 0xf5uy; 0xf0uy; 0x3euy; 0x44uy; 0x15uy; 0x59uy; 0xe0uy; 0xc5uy; 0x44uy; 0x86uy; 0xc3uy; 0x91uy; 0xa8uy; 0x75uy; 0xc0uy; 0x12uy; 0x46uy; 0xbauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let nonce7: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0euy; 0x0duy; 0x57uy; 0xbbuy; 0x7buy; 0x40uy; 0x54uy; 0x02uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce7_len: (x:UInt32.t { UInt32.v x = B.length nonce7 }) =
12ul
let aad7: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad7_len: (x:UInt32.t { UInt32.v x = B.length aad7 }) =
0ul
let input7: (b: B.buffer UInt8.t { B.length b = 512 /\ B.recallable b /\ B.disjoint b aad7 }) =
B.recall aad7;[@inline_let] let l = [ 0xc3uy; 0x09uy; 0x94uy; 0x62uy; 0xe6uy; 0x46uy; 0x2euy; 0x10uy; 0xbeuy; 0x00uy; 0xe4uy; 0xfcuy; 0xf3uy; 0x40uy; 0xa3uy; 0xe2uy; 0x0fuy; 0xc2uy; 0x8buy; 0x28uy; 0xdcuy; 0xbauy; 0xb4uy; 0x3cuy; 0xe4uy; 0x21uy; 0x58uy; 0x61uy; 0xcduy; 0x8buy; 0xcduy; 0xfbuy; 0xacuy; 0x94uy; 0xa1uy; 0x45uy; 0xf5uy; 0x1cuy; 0xe1uy; 0x12uy; 0xe0uy; 0x3buy; 0x67uy; 0x21uy; 0x54uy; 0x5euy; 0x8cuy; 0xaauy; 0xcfuy; 0xdbuy; 0xb4uy; 0x51uy; 0xd4uy; 0x13uy; 0xdauy; 0xe6uy; 0x83uy; 0x89uy; 0xb6uy; 0x92uy; 0xe9uy; 0x21uy; 0x76uy; 0xa4uy; 0x93uy; 0x7duy; 0x0euy; 0xfduy; 0x96uy; 0x36uy; 0x03uy; 0x91uy; 0x43uy; 0x5cuy; 0x92uy; 0x49uy; 0x62uy; 0x61uy; 0x7buy; 0xebuy; 0x43uy; 0x89uy; 0xb8uy; 0x12uy; 0x20uy; 0x43uy; 0xd4uy; 0x47uy; 0x06uy; 0x84uy; 0xeeuy; 0x47uy; 0xe9uy; 0x8auy; 0x73uy; 0x15uy; 0x0fuy; 0x72uy; 0xcfuy; 0xeduy; 0xceuy; 0x96uy; 0xb2uy; 0x7fuy; 0x21uy; 0x45uy; 0x76uy; 0xebuy; 0x26uy; 0x28uy; 0x83uy; 0x6auy; 0xaduy; 0xaauy; 0xa6uy; 0x81uy; 0xd8uy; 0x55uy; 0xb1uy; 0xa3uy; 0x85uy; 0xb3uy; 0x0cuy; 0xdfuy; 0xf1uy; 0x69uy; 0x2duy; 0x97uy; 0x05uy; 0x2auy; 0xbcuy; 0x7cuy; 0x7buy; 0x25uy; 0xf8uy; 0x80uy; 0x9duy; 0x39uy; 0x25uy; 0xf3uy; 0x62uy; 0xf0uy; 0x66uy; 0x5euy; 0xf4uy; 0xa0uy; 0xcfuy; 0xd8uy; 0xfduy; 0x4fuy; 0xb1uy; 0x1fuy; 0x60uy; 0x3auy; 0x08uy; 0x47uy; 0xafuy; 0xe1uy; 0xf6uy; 0x10uy; 0x77uy; 0x09uy; 0xa7uy; 0x27uy; 0x8fuy; 0x9auy; 0x97uy; 0x5auy; 0x26uy; 0xfauy; 0xfeuy; 0x41uy; 0x32uy; 0x83uy; 0x10uy; 0xe0uy; 0x1duy; 0xbfuy; 0x64uy; 0x0duy; 0xf4uy; 0x1cuy; 0x32uy; 0x35uy; 0xe5uy; 0x1buy; 0x36uy; 0xefuy; 0xd4uy; 0x4auy; 0x93uy; 0x4duy; 0x00uy; 0x7cuy; 0xecuy; 0x02uy; 0x07uy; 0x8buy; 0x5duy; 0x7duy; 0x1buy; 0x0euy; 0xd1uy; 0xa6uy; 0xa5uy; 0x5duy; 0x7duy; 0x57uy; 0x88uy; 0xa8uy; 0xccuy; 0x81uy; 0xb4uy; 0x86uy; 0x4euy; 0xb4uy; 0x40uy; 0xe9uy; 0x1duy; 0xc3uy; 0xb1uy; 0x24uy; 0x3euy; 0x7fuy; 0xccuy; 0x8auy; 0x24uy; 0x9buy; 0xdfuy; 0x6duy; 0xf0uy; 0x39uy; 0x69uy; 0x3euy; 0x4cuy; 0xc0uy; 0x96uy; 0xe4uy; 0x13uy; 0xdauy; 0x90uy; 0xdauy; 0xf4uy; 0x95uy; 0x66uy; 0x8buy; 0x17uy; 0x17uy; 0xfeuy; 0x39uy; 0x43uy; 0x25uy; 0xaauy; 0xdauy; 0xa0uy; 0x43uy; 0x3cuy; 0xb1uy; 0x41uy; 0x02uy; 0xa3uy; 0xf0uy; 0xa7uy; 0x19uy; 0x59uy; 0xbcuy; 0x1duy; 0x7duy; 0x6cuy; 0x6duy; 0x91uy; 0x09uy; 0x5cuy; 0xb7uy; 0x5buy; 0x01uy; 0xd1uy; 0x6fuy; 0x17uy; 0x21uy; 0x97uy; 0xbfuy; 0x89uy; 0x71uy; 0xa5uy; 0xb0uy; 0x6euy; 0x07uy; 0x45uy; 0xfduy; 0x9duy; 0xeauy; 0x07uy; 0xf6uy; 0x7auy; 0x9fuy; 0x10uy; 0x18uy; 0x22uy; 0x30uy; 0x73uy; 0xacuy; 0xd4uy; 0x6buy; 0x72uy; 0x44uy; 0xeduy; 0xd9uy; 0x19uy; 0x9buy; 0x2duy; 0x4auy; 0x41uy; 0xdduy; 0xd1uy; 0x85uy; 0x5euy; 0x37uy; 0x19uy; 0xeduy; 0xd2uy; 0x15uy; 0x8fuy; 0x5euy; 0x91uy; 0xdbuy; 0x33uy; 0xf2uy; 0xe4uy; 0xdbuy; 0xffuy; 0x98uy; 0xfbuy; 0xa3uy; 0xb5uy; 0xcauy; 0x21uy; 0x69uy; 0x08uy; 0xe7uy; 0x8auy; 0xdfuy; 0x90uy; 0xffuy; 0x3euy; 0xe9uy; 0x20uy; 0x86uy; 0x3cuy; 0xe9uy; 0xfcuy; 0x0buy; 0xfeuy; 0x5cuy; 0x61uy; 0xaauy; 0x13uy; 0x92uy; 0x7fuy; 0x7buy; 0xecuy; 0xe0uy; 0x6duy; 0xa8uy; 0x23uy; 0x22uy; 0xf6uy; 0x6buy; 0x77uy; 0xc4uy; 0xfeuy; 0x40uy; 0x07uy; 0x3buy; 0xb6uy; 0xf6uy; 0x8euy; 0x5fuy; 0xd4uy; 0xb9uy; 0xb7uy; 0x0fuy; 0x21uy; 0x04uy; 0xefuy; 0x83uy; 0x63uy; 0x91uy; 0x69uy; 0x40uy; 0xa3uy; 0x48uy; 0x5cuy; 0xd2uy; 0x60uy; 0xf9uy; 0x4fuy; 0x6cuy; 0x47uy; 0x8buy; 0x3buy; 0xb1uy; 0x9fuy; 0x8euy; 0xeeuy; 0x16uy; 0x8auy; 0x13uy; 0xfcuy; 0x46uy; 0x17uy; 0xc3uy; 0xc3uy; 0x32uy; 0x56uy; 0xf8uy; 0x3cuy; 0x85uy; 0x3auy; 0xb6uy; 0x3euy; 0xaauy; 0x89uy; 0x4fuy; 0xb3uy; 0xdfuy; 0x38uy; 0xfduy; 0xf1uy; 0xe4uy; 0x3auy; 0xc0uy; 0xe6uy; 0x58uy; 0xb5uy; 0x8fuy; 0xc5uy; 0x29uy; 0xa2uy; 0x92uy; 0x4auy; 0xb6uy; 0xa0uy; 0x34uy; 0x7fuy; 0xabuy; 0xb5uy; 0x8auy; 0x90uy; 0xa1uy; 0xdbuy; 0x4duy; 0xcauy; 0xb6uy; 0x2cuy; 0x41uy; 0x3cuy; 0xf7uy; 0x2buy; 0x21uy; 0xc3uy; 0xfduy; 0xf4uy; 0x17uy; 0x5cuy; 0xb5uy; 0x33uy; 0x17uy; 0x68uy; 0x2buy; 0x08uy; 0x30uy; 0xf3uy; 0xf7uy; 0x30uy; 0x3cuy; 0x96uy; 0xe6uy; 0x6auy; 0x20uy; 0x97uy; 0xe7uy; 0x4duy; 0x10uy; 0x5fuy; 0x47uy; 0x5fuy; 0x49uy; 0x96uy; 0x09uy; 0xf0uy; 0x27uy; 0x91uy; 0xc8uy; 0xf8uy; 0x5auy; 0x2euy; 0x79uy; 0xb5uy; 0xe2uy; 0xb8uy; 0xe8uy; 0xb9uy; 0x7buy; 0xd5uy; 0x10uy; 0xcbuy; 0xffuy; 0x5duy; 0x14uy; 0x73uy; 0xf3uy; ] in
assert_norm (List.Tot.length l = 512);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
512ul
let output7: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy; 0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy; 0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy; 0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy; 0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy; 0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy; 0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy; 0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy; 0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy; 0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy; 0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy; 0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy; 0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy; 0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy; 0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy; 0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy; 0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy; 0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy; 0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy; 0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy; 0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy; 0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy; 0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy; 0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy; 0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy; 0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy; 0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy; 0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy; 0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy; 0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy; 0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy; 0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy; 0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy; 0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy; 0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy; 0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy; 0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy; 0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy; 0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy; 0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy; 0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy; 0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy; 0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy; 0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output7_len: (x:UInt32.t { UInt32.v x = B.length output7 }) =
528ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeauy; 0xbcuy; 0x56uy; 0x99uy; 0xe3uy; 0x50uy; 0xffuy; 0xc5uy; 0xccuy; 0x1auy; 0xd7uy; 0xc1uy; 0x57uy; 0x72uy; 0xeauy; 0x86uy; 0x5buy; 0x89uy; 0x88uy; 0x61uy; 0x3duy; 0x2fuy; 0x9buy; 0xb2uy; 0xe7uy; 0x9cuy; 0xecuy; 0x74uy; 0x6euy; 0x3euy; 0xf4uy; 0x3buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let nonce8: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xefuy; 0x2duy; 0x63uy; 0xeeuy; 0x6buy; 0x80uy; 0x8buy; 0x78uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce8_len: (x:UInt32.t { UInt32.v x = B.length nonce8 }) =
12ul
let aad8: (b: B.buffer UInt8.t { B.length b = 9 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5auy; 0x27uy; 0xffuy; 0xebuy; 0xdfuy; 0x84uy; 0xb2uy; 0x9euy; 0xefuy; ] in
assert_norm (List.Tot.length l = 9);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad8_len: (x:UInt32.t { UInt32.v x = B.length aad8 }) =
9ul
let input8: (b: B.buffer UInt8.t { B.length b = 513 /\ B.recallable b /\ B.disjoint b aad8 }) =
B.recall aad8;[@inline_let] let l = [ 0xe6uy; 0xc3uy; 0xdbuy; 0x63uy; 0x55uy; 0x15uy; 0xe3uy; 0x5buy; 0xb7uy; 0x4buy; 0x27uy; 0x8buy; 0x5auy; 0xdduy; 0xc2uy; 0xe8uy; 0x3auy; 0x6buy; 0xd7uy; 0x81uy; 0x96uy; 0x35uy; 0x97uy; 0xcauy; 0xd7uy; 0x68uy; 0xe8uy; 0xefuy; 0xceuy; 0xabuy; 0xdauy; 0x09uy; 0x6euy; 0xd6uy; 0x8euy; 0xcbuy; 0x55uy; 0xb5uy; 0xe1uy; 0xe5uy; 0x57uy; 0xfduy; 0xc4uy; 0xe3uy; 0xe0uy; 0x18uy; 0x4fuy; 0x85uy; 0xf5uy; 0x3fuy; 0x7euy; 0x4buy; 0x88uy; 0xc9uy; 0x52uy; 0x44uy; 0x0fuy; 0xeauy; 0xafuy; 0x1fuy; 0x71uy; 0x48uy; 0x9fuy; 0x97uy; 0x6duy; 0xb9uy; 0x6fuy; 0x00uy; 0xa6uy; 0xdeuy; 0x2buy; 0x77uy; 0x8buy; 0x15uy; 0xaduy; 0x10uy; 0xa0uy; 0x2buy; 0x7buy; 0x41uy; 0x90uy; 0x03uy; 0x2duy; 0x69uy; 0xaeuy; 0xccuy; 0x77uy; 0x7cuy; 0xa5uy; 0x9duy; 0x29uy; 0x22uy; 0xc2uy; 0xeauy; 0xb4uy; 0x00uy; 0x1auy; 0xd2uy; 0x7auy; 0x98uy; 0x8auy; 0xf9uy; 0xf7uy; 0x82uy; 0xb0uy; 0xabuy; 0xd8uy; 0xa6uy; 0x94uy; 0x8duy; 0x58uy; 0x2fuy; 0x01uy; 0x9euy; 0x00uy; 0x20uy; 0xfcuy; 0x49uy; 0xdcuy; 0x0euy; 0x03uy; 0xe8uy; 0x45uy; 0x10uy; 0xd6uy; 0xa8uy; 0xdauy; 0x55uy; 0x10uy; 0x9auy; 0xdfuy; 0x67uy; 0x22uy; 0x8buy; 0x43uy; 0xabuy; 0x00uy; 0xbbuy; 0x02uy; 0xc8uy; 0xdduy; 0x7buy; 0x97uy; 0x17uy; 0xd7uy; 0x1duy; 0x9euy; 0x02uy; 0x5euy; 0x48uy; 0xdeuy; 0x8euy; 0xcfuy; 0x99uy; 0x07uy; 0x95uy; 0x92uy; 0x3cuy; 0x5fuy; 0x9fuy; 0xc5uy; 0x8auy; 0xc0uy; 0x23uy; 0xaauy; 0xd5uy; 0x8cuy; 0x82uy; 0x6euy; 0x16uy; 0x92uy; 0xb1uy; 0x12uy; 0x17uy; 0x07uy; 0xc3uy; 0xfbuy; 0x36uy; 0xf5uy; 0x6cuy; 0x35uy; 0xd6uy; 0x06uy; 0x1fuy; 0x9fuy; 0xa7uy; 0x94uy; 0xa2uy; 0x38uy; 0x63uy; 0x9cuy; 0xb0uy; 0x71uy; 0xb3uy; 0xa5uy; 0xd2uy; 0xd8uy; 0xbauy; 0x9fuy; 0x08uy; 0x01uy; 0xb3uy; 0xffuy; 0x04uy; 0x97uy; 0x73uy; 0x45uy; 0x1buy; 0xd5uy; 0xa9uy; 0x9cuy; 0x80uy; 0xafuy; 0x04uy; 0x9auy; 0x85uy; 0xdbuy; 0x32uy; 0x5buy; 0x5duy; 0x1auy; 0xc1uy; 0x36uy; 0x28uy; 0x10uy; 0x79uy; 0xf1uy; 0x3cuy; 0xbfuy; 0x1auy; 0x41uy; 0x5cuy; 0x4euy; 0xdfuy; 0xb2uy; 0x7cuy; 0x79uy; 0x3buy; 0x7auy; 0x62uy; 0x3duy; 0x4buy; 0xc9uy; 0x9buy; 0x2auy; 0x2euy; 0x7cuy; 0xa2uy; 0xb1uy; 0x11uy; 0x98uy; 0xa7uy; 0x34uy; 0x1auy; 0x00uy; 0xf3uy; 0xd1uy; 0xbcuy; 0x18uy; 0x22uy; 0xbauy; 0x02uy; 0x56uy; 0x62uy; 0x31uy; 0x10uy; 0x11uy; 0x6duy; 0xe0uy; 0x54uy; 0x9duy; 0x40uy; 0x1fuy; 0x26uy; 0x80uy; 0x41uy; 0xcauy; 0x3fuy; 0x68uy; 0x0fuy; 0x32uy; 0x1duy; 0x0auy; 0x8euy; 0x79uy; 0xd8uy; 0xa4uy; 0x1buy; 0x29uy; 0x1cuy; 0x90uy; 0x8euy; 0xc5uy; 0xe3uy; 0xb4uy; 0x91uy; 0x37uy; 0x9auy; 0x97uy; 0x86uy; 0x99uy; 0xd5uy; 0x09uy; 0xc5uy; 0xbbuy; 0xa3uy; 0x3fuy; 0x21uy; 0x29uy; 0x82uy; 0x14uy; 0x5cuy; 0xabuy; 0x25uy; 0xfbuy; 0xf2uy; 0x4fuy; 0x58uy; 0x26uy; 0xd4uy; 0x83uy; 0xaauy; 0x66uy; 0x89uy; 0x67uy; 0x7euy; 0xc0uy; 0x49uy; 0xe1uy; 0x11uy; 0x10uy; 0x7fuy; 0x7auy; 0xdauy; 0x29uy; 0x04uy; 0xffuy; 0xf0uy; 0xcbuy; 0x09uy; 0x7cuy; 0x9duy; 0xfauy; 0x03uy; 0x6fuy; 0x81uy; 0x09uy; 0x31uy; 0x60uy; 0xfbuy; 0x08uy; 0xfauy; 0x74uy; 0xd3uy; 0x64uy; 0x44uy; 0x7cuy; 0x55uy; 0x85uy; 0xecuy; 0x9cuy; 0x6euy; 0x25uy; 0xb7uy; 0x6cuy; 0xc5uy; 0x37uy; 0xb6uy; 0x83uy; 0x87uy; 0x72uy; 0x95uy; 0x8buy; 0x9duy; 0xe1uy; 0x69uy; 0x5cuy; 0x31uy; 0x95uy; 0x42uy; 0xa6uy; 0x2cuy; 0xd1uy; 0x36uy; 0x47uy; 0x1fuy; 0xecuy; 0x54uy; 0xabuy; 0xa2uy; 0x1cuy; 0xd8uy; 0x00uy; 0xccuy; 0xbcuy; 0x0duy; 0x65uy; 0xe2uy; 0x67uy; 0xbfuy; 0xbcuy; 0xeauy; 0xeeuy; 0x9euy; 0xe4uy; 0x36uy; 0x95uy; 0xbeuy; 0x73uy; 0xd9uy; 0xa6uy; 0xd9uy; 0x0fuy; 0xa0uy; 0xccuy; 0x82uy; 0x76uy; 0x26uy; 0xaduy; 0x5buy; 0x58uy; 0x6cuy; 0x4euy; 0xabuy; 0x29uy; 0x64uy; 0xd3uy; 0xd9uy; 0xa9uy; 0x08uy; 0x8cuy; 0x1duy; 0xa1uy; 0x4fuy; 0x80uy; 0xd8uy; 0x3fuy; 0x94uy; 0xfbuy; 0xd3uy; 0x7buy; 0xfcuy; 0xd1uy; 0x2buy; 0xc3uy; 0x21uy; 0xebuy; 0xe5uy; 0x1cuy; 0x84uy; 0x23uy; 0x7fuy; 0x4buy; 0xfauy; 0xdbuy; 0x34uy; 0x18uy; 0xa2uy; 0xc2uy; 0xe5uy; 0x13uy; 0xfeuy; 0x6cuy; 0x49uy; 0x81uy; 0xd2uy; 0x73uy; 0xe7uy; 0xe2uy; 0xd7uy; 0xe4uy; 0x4fuy; 0x4buy; 0x08uy; 0x6euy; 0xb1uy; 0x12uy; 0x22uy; 0x10uy; 0x9duy; 0xacuy; 0x51uy; 0x1euy; 0x17uy; 0xd9uy; 0x8auy; 0x0buy; 0x42uy; 0x88uy; 0x16uy; 0x81uy; 0x37uy; 0x7cuy; 0x6auy; 0xf7uy; 0xefuy; 0x2duy; 0xe3uy; 0xd9uy; 0xf8uy; 0x5fuy; 0xe0uy; 0x53uy; 0x27uy; 0x74uy; 0xb9uy; 0xe2uy; 0xd6uy; 0x1cuy; 0x80uy; 0x2cuy; 0x52uy; 0x65uy; ] in
assert_norm (List.Tot.length l = 513);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
513ul
let output8: (b: B.buffer UInt8.t { B.length b = 529 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0x81uy; 0x8duy; 0xd0uy; 0x3duy; 0xb4uy; 0xd5uy; 0xdfuy; 0xd3uy; 0x42uy; 0x47uy; 0x5auy; 0x6duy; 0x19uy; 0x27uy; 0x66uy; 0x4buy; 0x2euy; 0x0cuy; 0x27uy; 0x9cuy; 0x96uy; 0x4cuy; 0x72uy; 0x02uy; 0xa3uy; 0x65uy; 0xc3uy; 0xb3uy; 0x6fuy; 0x2euy; 0xbduy; 0x63uy; 0x8auy; 0x4auy; 0x5duy; 0x29uy; 0xa2uy; 0xd0uy; 0x28uy; 0x48uy; 0xc5uy; 0x3duy; 0x98uy; 0xa3uy; 0xbcuy; 0xe0uy; 0xbeuy; 0x3buy; 0x3fuy; 0xe6uy; 0x8auy; 0xa4uy; 0x7fuy; 0x53uy; 0x06uy; 0xfauy; 0x7fuy; 0x27uy; 0x76uy; 0x72uy; 0x31uy; 0xa1uy; 0xf5uy; 0xd6uy; 0x0cuy; 0x52uy; 0x47uy; 0xbauy; 0xcduy; 0x4fuy; 0xd7uy; 0xebuy; 0x05uy; 0x48uy; 0x0duy; 0x7cuy; 0x35uy; 0x4auy; 0x09uy; 0xc9uy; 0x76uy; 0x71uy; 0x02uy; 0xa3uy; 0xfbuy; 0xb7uy; 0x1auy; 0x65uy; 0xb7uy; 0xeduy; 0x98uy; 0xc6uy; 0x30uy; 0x8auy; 0x00uy; 0xaeuy; 0xa1uy; 0x31uy; 0xe5uy; 0xb5uy; 0x9euy; 0x6duy; 0x62uy; 0xdauy; 0xdauy; 0x07uy; 0x0fuy; 0x38uy; 0x38uy; 0xd3uy; 0xcbuy; 0xc1uy; 0xb0uy; 0xaduy; 0xecuy; 0x72uy; 0xecuy; 0xb1uy; 0xa2uy; 0x7buy; 0x59uy; 0xf3uy; 0x3duy; 0x2buy; 0xefuy; 0xcduy; 0x28uy; 0x5buy; 0x83uy; 0xccuy; 0x18uy; 0x91uy; 0x88uy; 0xb0uy; 0x2euy; 0xf9uy; 0x29uy; 0x31uy; 0x18uy; 0xf9uy; 0x4euy; 0xe9uy; 0x0auy; 0x91uy; 0x92uy; 0x9fuy; 0xaeuy; 0x2duy; 0xaduy; 0xf4uy; 0xe6uy; 0x1auy; 0xe2uy; 0xa4uy; 0xeeuy; 0x47uy; 0x15uy; 0xbfuy; 0x83uy; 0x6euy; 0xd7uy; 0x72uy; 0x12uy; 0x3buy; 0x2duy; 0x24uy; 0xe9uy; 0xb2uy; 0x55uy; 0xcbuy; 0x3cuy; 0x10uy; 0xf0uy; 0x24uy; 0x8auy; 0x4auy; 0x02uy; 0xeauy; 0x90uy; 0x25uy; 0xf0uy; 0xb4uy; 0x79uy; 0x3auy; 0xefuy; 0x6euy; 0xf5uy; 0x52uy; 0xdfuy; 0xb0uy; 0x0auy; 0xcduy; 0x24uy; 0x1cuy; 0xd3uy; 0x2euy; 0x22uy; 0x74uy; 0xeauy; 0x21uy; 0x6fuy; 0xe9uy; 0xbduy; 0xc8uy; 0x3euy; 0x36uy; 0x5buy; 0x19uy; 0xf1uy; 0xcauy; 0x99uy; 0x0auy; 0xb4uy; 0xa7uy; 0x52uy; 0x1auy; 0x4euy; 0xf2uy; 0xaduy; 0x8duy; 0x56uy; 0x85uy; 0xbbuy; 0x64uy; 0x89uy; 0xbauy; 0x26uy; 0xf9uy; 0xc7uy; 0xe1uy; 0x89uy; 0x19uy; 0x22uy; 0x77uy; 0xc3uy; 0xa8uy; 0xfcuy; 0xffuy; 0xaduy; 0xfeuy; 0xb9uy; 0x48uy; 0xaeuy; 0x12uy; 0x30uy; 0x9fuy; 0x19uy; 0xfbuy; 0x1buy; 0xefuy; 0x14uy; 0x87uy; 0x8auy; 0x78uy; 0x71uy; 0xf3uy; 0xf4uy; 0xb7uy; 0x00uy; 0x9cuy; 0x1duy; 0xb5uy; 0x3duy; 0x49uy; 0x00uy; 0x0cuy; 0x06uy; 0xd4uy; 0x50uy; 0xf9uy; 0x54uy; 0x45uy; 0xb2uy; 0x5buy; 0x43uy; 0xdbuy; 0x6duy; 0xcfuy; 0x1auy; 0xe9uy; 0x7auy; 0x7auy; 0xcfuy; 0xfcuy; 0x8auy; 0x4euy; 0x4duy; 0x0buy; 0x07uy; 0x63uy; 0x28uy; 0xd8uy; 0xe7uy; 0x08uy; 0x95uy; 0xdfuy; 0xa6uy; 0x72uy; 0x93uy; 0x2euy; 0xbbuy; 0xa0uy; 0x42uy; 0x89uy; 0x16uy; 0xf1uy; 0xd9uy; 0x0cuy; 0xf9uy; 0xa1uy; 0x16uy; 0xfduy; 0xd9uy; 0x03uy; 0xb4uy; 0x3buy; 0x8auy; 0xf5uy; 0xf6uy; 0xe7uy; 0x6buy; 0x2euy; 0x8euy; 0x4cuy; 0x3duy; 0xe2uy; 0xafuy; 0x08uy; 0x45uy; 0x03uy; 0xffuy; 0x09uy; 0xb6uy; 0xebuy; 0x2duy; 0xc6uy; 0x1buy; 0x88uy; 0x94uy; 0xacuy; 0x3euy; 0xf1uy; 0x9fuy; 0x0euy; 0x0euy; 0x2buy; 0xd5uy; 0x00uy; 0x4duy; 0x3fuy; 0x3buy; 0x53uy; 0xaeuy; 0xafuy; 0x1cuy; 0x33uy; 0x5fuy; 0x55uy; 0x6euy; 0x8duy; 0xafuy; 0x05uy; 0x7auy; 0x10uy; 0x34uy; 0xc9uy; 0xf4uy; 0x66uy; 0xcbuy; 0x62uy; 0x12uy; 0xa6uy; 0xeeuy; 0xe8uy; 0x1cuy; 0x5duy; 0x12uy; 0x86uy; 0xdbuy; 0x6fuy; 0x1cuy; 0x33uy; 0xc4uy; 0x1cuy; 0xdauy; 0x82uy; 0x2duy; 0x3buy; 0x59uy; 0xfeuy; 0xb1uy; 0xa4uy; 0x59uy; 0x41uy; 0x86uy; 0xd0uy; 0xefuy; 0xaeuy; 0xfbuy; 0xdauy; 0x6duy; 0x11uy; 0xb8uy; 0xcauy; 0xe9uy; 0x6euy; 0xffuy; 0xf7uy; 0xa9uy; 0xd9uy; 0x70uy; 0x30uy; 0xfcuy; 0x53uy; 0xe2uy; 0xd7uy; 0xa2uy; 0x4euy; 0xc7uy; 0x91uy; 0xd9uy; 0x07uy; 0x06uy; 0xaauy; 0xdduy; 0xb0uy; 0x59uy; 0x28uy; 0x1duy; 0x00uy; 0x66uy; 0xc5uy; 0x54uy; 0xc2uy; 0xfcuy; 0x06uy; 0xdauy; 0x05uy; 0x90uy; 0x52uy; 0x1duy; 0x37uy; 0x66uy; 0xeeuy; 0xf0uy; 0xb2uy; 0x55uy; 0x8auy; 0x5duy; 0xd2uy; 0x38uy; 0x86uy; 0x94uy; 0x9buy; 0xfcuy; 0x10uy; 0x4cuy; 0xa1uy; 0xb9uy; 0x64uy; 0x3euy; 0x44uy; 0xb8uy; 0x5fuy; 0xb0uy; 0x0cuy; 0xecuy; 0xe0uy; 0xc9uy; 0xe5uy; 0x62uy; 0x75uy; 0x3fuy; 0x09uy; 0xd5uy; 0xf5uy; 0xd9uy; 0x26uy; 0xbauy; 0x9euy; 0xd2uy; 0xf4uy; 0xb9uy; 0x48uy; 0x0auy; 0xbcuy; 0xa2uy; 0xd6uy; 0x7cuy; 0x36uy; 0x11uy; 0x7duy; 0x26uy; 0x81uy; 0x89uy; 0xcfuy; 0xa4uy; 0xaduy; 0x73uy; 0x0euy; 0xeeuy; 0xccuy; 0x06uy; 0xa9uy; 0xdbuy; 0xb1uy; 0xfduy; 0xfbuy; 0x09uy; 0x7fuy; 0x90uy; 0x42uy; 0x37uy; 0x2fuy; 0xe1uy; 0x9cuy; 0x0fuy; 0x6fuy; 0xcfuy; 0x43uy; 0xb5uy; 0xd9uy; 0x90uy; 0xe1uy; 0x85uy; 0xf5uy; 0xa8uy; 0xaeuy; ] in
assert_norm (List.Tot.length l = 529);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output8_len: (x:UInt32.t { UInt32.v x = B.length output8 }) =
529ul
let key9: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x47uy; 0x11uy; 0xebuy; 0x86uy; 0x2buy; 0x2cuy; 0xabuy; 0x44uy; 0x34uy; 0xdauy; 0x7fuy; 0x57uy; 0x03uy; 0x39uy; 0x0cuy; 0xafuy; 0x2cuy; 0x14uy; 0xfduy; 0x65uy; 0x23uy; 0xe9uy; 0x8euy; 0x74uy; 0xd5uy; 0x08uy; 0x68uy; 0x08uy; 0xe7uy; 0xb4uy; 0x72uy; 0xd7uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key9_len: (x:UInt32.t { UInt32.v x = B.length key9 }) =
32ul
let nonce9: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdbuy; 0x92uy; 0x0fuy; 0x7fuy; 0x17uy; 0x54uy; 0x0cuy; 0x30uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce9_len: (x:UInt32.t { UInt32.v x = B.length nonce9 }) =
12ul
let aad9: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xd2uy; 0xa1uy; 0x70uy; 0xdbuy; 0x7auy; 0xf8uy; 0xfauy; 0x27uy; 0xbauy; 0x73uy; 0x0fuy; 0xbfuy; 0x3duy; 0x1euy; 0x82uy; 0xb2uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad9_len: (x:UInt32.t { UInt32.v x = B.length aad9 }) =
16ul
let input9: (b: B.buffer UInt8.t { B.length b = 1024 /\ B.recallable b /\ B.disjoint b aad9 }) =
B.recall aad9;[@inline_let] let l = [ 0x42uy; 0x93uy; 0xe4uy; 0xebuy; 0x97uy; 0xb0uy; 0x57uy; 0xbfuy; 0x1auy; 0x8buy; 0x1fuy; 0xe4uy; 0x5fuy; 0x36uy; 0x20uy; 0x3cuy; 0xefuy; 0x0auy; 0xa9uy; 0x48uy; 0x5fuy; 0x5fuy; 0x37uy; 0x22uy; 0x3auy; 0xdeuy; 0xe3uy; 0xaeuy; 0xbeuy; 0xaduy; 0x07uy; 0xccuy; 0xb1uy; 0xf6uy; 0xf5uy; 0xf9uy; 0x56uy; 0xdduy; 0xe7uy; 0x16uy; 0x1euy; 0x7fuy; 0xdfuy; 0x7auy; 0x9euy; 0x75uy; 0xb7uy; 0xc7uy; 0xbeuy; 0xbeuy; 0x8auy; 0x36uy; 0x04uy; 0xc0uy; 0x10uy; 0xf4uy; 0x95uy; 0x20uy; 0x03uy; 0xecuy; 0xdcuy; 0x05uy; 0xa1uy; 0x7duy; 0xc4uy; 0xa9uy; 0x2cuy; 0x82uy; 0xd0uy; 0xbcuy; 0x8buy; 0xc5uy; 0xc7uy; 0x45uy; 0x50uy; 0xf6uy; 0xa2uy; 0x1auy; 0xb5uy; 0x46uy; 0x3buy; 0x73uy; 0x02uy; 0xa6uy; 0x83uy; 0x4buy; 0x73uy; 0x82uy; 0x58uy; 0x5euy; 0x3buy; 0x65uy; 0x2fuy; 0x0euy; 0xfduy; 0x2buy; 0x59uy; 0x16uy; 0xceuy; 0xa1uy; 0x60uy; 0x9cuy; 0xe8uy; 0x3auy; 0x99uy; 0xeduy; 0x8duy; 0x5auy; 0xcfuy; 0xf6uy; 0x83uy; 0xafuy; 0xbauy; 0xd7uy; 0x73uy; 0x73uy; 0x40uy; 0x97uy; 0x3duy; 0xcauy; 0xefuy; 0x07uy; 0x57uy; 0xe6uy; 0xd9uy; 0x70uy; 0x0euy; 0x95uy; 0xaeuy; 0xa6uy; 0x8duy; 0x04uy; 0xccuy; 0xeeuy; 0xf7uy; 0x09uy; 0x31uy; 0x77uy; 0x12uy; 0xa3uy; 0x23uy; 0x97uy; 0x62uy; 0xb3uy; 0x7buy; 0x32uy; 0xfbuy; 0x80uy; 0x14uy; 0x48uy; 0x81uy; 0xc3uy; 0xe5uy; 0xeauy; 0x91uy; 0x39uy; 0x52uy; 0x81uy; 0xa2uy; 0x4fuy; 0xe4uy; 0xb3uy; 0x09uy; 0xffuy; 0xdeuy; 0x5euy; 0xe9uy; 0x58uy; 0x84uy; 0x6euy; 0xf9uy; 0x3duy; 0xdfuy; 0x25uy; 0xeauy; 0xaduy; 0xaeuy; 0xe6uy; 0x9auy; 0xd1uy; 0x89uy; 0x55uy; 0xd3uy; 0xdeuy; 0x6cuy; 0x52uy; 0xdbuy; 0x70uy; 0xfeuy; 0x37uy; 0xceuy; 0x44uy; 0x0auy; 0xa8uy; 0x25uy; 0x5fuy; 0x92uy; 0xc1uy; 0x33uy; 0x4auy; 0x4fuy; 0x9buy; 0x62uy; 0x35uy; 0xffuy; 0xceuy; 0xc0uy; 0xa9uy; 0x60uy; 0xceuy; 0x52uy; 0x00uy; 0x97uy; 0x51uy; 0x35uy; 0x26uy; 0x2euy; 0xb9uy; 0x36uy; 0xa9uy; 0x87uy; 0x6euy; 0x1euy; 0xccuy; 0x91uy; 0x78uy; 0x53uy; 0x98uy; 0x86uy; 0x5buy; 0x9cuy; 0x74uy; 0x7duy; 0x88uy; 0x33uy; 0xe1uy; 0xdfuy; 0x37uy; 0x69uy; 0x2buy; 0xbbuy; 0xf1uy; 0x4duy; 0xf4uy; 0xd1uy; 0xf1uy; 0x39uy; 0x93uy; 0x17uy; 0x51uy; 0x19uy; 0xe3uy; 0x19uy; 0x1euy; 0x76uy; 0x37uy; 0x25uy; 0xfbuy; 0x09uy; 0x27uy; 0x6auy; 0xabuy; 0x67uy; 0x6fuy; 0x14uy; 0x12uy; 0x64uy; 0xe7uy; 0xc4uy; 0x07uy; 0xdfuy; 0x4duy; 0x17uy; 0xbbuy; 0x6duy; 0xe0uy; 0xe9uy; 0xb9uy; 0xabuy; 0xcauy; 0x10uy; 0x68uy; 0xafuy; 0x7euy; 0xb7uy; 0x33uy; 0x54uy; 0x73uy; 0x07uy; 0x6euy; 0xf7uy; 0x81uy; 0x97uy; 0x9cuy; 0x05uy; 0x6fuy; 0x84uy; 0x5fuy; 0xd2uy; 0x42uy; 0xfbuy; 0x38uy; 0xcfuy; 0xd1uy; 0x2fuy; 0x14uy; 0x30uy; 0x88uy; 0x98uy; 0x4duy; 0x5auy; 0xa9uy; 0x76uy; 0xd5uy; 0x4fuy; 0x3euy; 0x70uy; 0x6cuy; 0x85uy; 0x76uy; 0xd7uy; 0x01uy; 0xa0uy; 0x1auy; 0xc8uy; 0x4euy; 0xaauy; 0xacuy; 0x78uy; 0xfeuy; 0x46uy; 0xdeuy; 0x6auy; 0x05uy; 0x46uy; 0xa7uy; 0x43uy; 0x0cuy; 0xb9uy; 0xdeuy; 0xb9uy; 0x68uy; 0xfbuy; 0xceuy; 0x42uy; 0x99uy; 0x07uy; 0x4duy; 0x0buy; 0x3buy; 0x5auy; 0x30uy; 0x35uy; 0xa8uy; 0xf9uy; 0x3auy; 0x73uy; 0xefuy; 0x0fuy; 0xdbuy; 0x1euy; 0x16uy; 0x42uy; 0xc4uy; 0xbauy; 0xaeuy; 0x58uy; 0xaauy; 0xf8uy; 0xe5uy; 0x75uy; 0x2fuy; 0x1buy; 0x15uy; 0x5cuy; 0xfduy; 0x0auy; 0x97uy; 0xd0uy; 0xe4uy; 0x37uy; 0x83uy; 0x61uy; 0x5fuy; 0x43uy; 0xa6uy; 0xc7uy; 0x3fuy; 0x38uy; 0x59uy; 0xe6uy; 0xebuy; 0xa3uy; 0x90uy; 0xc3uy; 0xaauy; 0xaauy; 0x5auy; 0xd3uy; 0x34uy; 0xd4uy; 0x17uy; 0xc8uy; 0x65uy; 0x3euy; 0x57uy; 0xbcuy; 0x5euy; 0xdduy; 0x9euy; 0xb7uy; 0xf0uy; 0x2euy; 0x5buy; 0xb2uy; 0x1fuy; 0x8auy; 0x08uy; 0x0duy; 0x45uy; 0x91uy; 0x0buy; 0x29uy; 0x53uy; 0x4fuy; 0x4cuy; 0x5auy; 0x73uy; 0x56uy; 0xfeuy; 0xafuy; 0x41uy; 0x01uy; 0x39uy; 0x0auy; 0x24uy; 0x3cuy; 0x7euy; 0xbeuy; 0x4euy; 0x53uy; 0xf3uy; 0xebuy; 0x06uy; 0x66uy; 0x51uy; 0x28uy; 0x1duy; 0xbduy; 0x41uy; 0x0auy; 0x01uy; 0xabuy; 0x16uy; 0x47uy; 0x27uy; 0x47uy; 0x47uy; 0xf7uy; 0xcbuy; 0x46uy; 0x0auy; 0x70uy; 0x9euy; 0x01uy; 0x9cuy; 0x09uy; 0xe1uy; 0x2auy; 0x00uy; 0x1auy; 0xd8uy; 0xd4uy; 0x79uy; 0x9duy; 0x80uy; 0x15uy; 0x8euy; 0x53uy; 0x2auy; 0x65uy; 0x83uy; 0x78uy; 0x3euy; 0x03uy; 0x00uy; 0x07uy; 0x12uy; 0x1fuy; 0x33uy; 0x3euy; 0x7buy; 0x13uy; 0x37uy; 0xf1uy; 0xc3uy; 0xefuy; 0xb7uy; 0xc1uy; 0x20uy; 0x3cuy; 0x3euy; 0x67uy; 0x66uy; 0x5duy; 0x88uy; 0xa7uy; 0x7duy; 0x33uy; 0x50uy; 0x77uy; 0xb0uy; 0x28uy; 0x8euy; 0xe7uy; 0x2cuy; 0x2euy; 0x7auy; 0xf4uy; 0x3cuy; 0x8duy; 0x74uy; 0x83uy; 0xafuy; 0x8euy; 0x87uy; 0x0fuy; 0xe4uy; 0x50uy; 0xffuy; 0x84uy; 0x5cuy; 0x47uy; 0x0cuy; 0x6auy; 0x49uy; 0xbfuy; 0x42uy; 0x86uy; 0x77uy; 0x15uy; 0x48uy; 0xa5uy; 0x90uy; 0x5duy; 0x93uy; 0xd6uy; 0x2auy; 0x11uy; 0xd5uy; 0xd5uy; 0x11uy; 0xaauy; 0xceuy; 0xe7uy; 0x6fuy; 0xa5uy; 0xb0uy; 0x09uy; 0x2cuy; 0x8duy; 0xd3uy; 0x92uy; 0xf0uy; 0x5auy; 0x2auy; 0xdauy; 0x5buy; 0x1euy; 0xd5uy; 0x9auy; 0xc4uy; 0xc4uy; 0xf3uy; 0x49uy; 0x74uy; 0x41uy; 0xcauy; 0xe8uy; 0xc1uy; 0xf8uy; 0x44uy; 0xd6uy; 0x3cuy; 0xaeuy; 0x6cuy; 0x1duy; 0x9auy; 0x30uy; 0x04uy; 0x4duy; 0x27uy; 0x0euy; 0xb1uy; 0x5fuy; 0x59uy; 0xa2uy; 0x24uy; 0xe8uy; 0xe1uy; 0x98uy; 0xc5uy; 0x6auy; 0x4cuy; 0xfeuy; 0x41uy; 0xd2uy; 0x27uy; 0x42uy; 0x52uy; 0xe1uy; 0xe9uy; 0x7duy; 0x62uy; 0xe4uy; 0x88uy; 0x0fuy; 0xaduy; 0xb2uy; 0x70uy; 0xcbuy; 0x9duy; 0x4cuy; 0x27uy; 0x2euy; 0x76uy; 0x1euy; 0x1auy; 0x63uy; 0x65uy; 0xf5uy; 0x3buy; 0xf8uy; 0x57uy; 0x69uy; 0xebuy; 0x5buy; 0x38uy; 0x26uy; 0x39uy; 0x33uy; 0x25uy; 0x45uy; 0x3euy; 0x91uy; 0xb8uy; 0xd8uy; 0xc7uy; 0xd5uy; 0x42uy; 0xc0uy; 0x22uy; 0x31uy; 0x74uy; 0xf4uy; 0xbcuy; 0x0cuy; 0x23uy; 0xf1uy; 0xcauy; 0xc1uy; 0x8duy; 0xd7uy; 0xbeuy; 0xc9uy; 0x62uy; 0xe4uy; 0x08uy; 0x1auy; 0xcfuy; 0x36uy; 0xd5uy; 0xfeuy; 0x55uy; 0x21uy; 0x59uy; 0x91uy; 0x87uy; 0x87uy; 0xdfuy; 0x06uy; 0xdbuy; 0xdfuy; 0x96uy; 0x45uy; 0x58uy; 0xdauy; 0x05uy; 0xcduy; 0x50uy; 0x4duy; 0xd2uy; 0x7duy; 0x05uy; 0x18uy; 0x73uy; 0x6auy; 0x8duy; 0x11uy; 0x85uy; 0xa6uy; 0x88uy; 0xe8uy; 0xdauy; 0xe6uy; 0x30uy; 0x33uy; 0xa4uy; 0x89uy; 0x31uy; 0x75uy; 0xbeuy; 0x69uy; 0x43uy; 0x84uy; 0x43uy; 0x50uy; 0x87uy; 0xdduy; 0x71uy; 0x36uy; 0x83uy; 0xc3uy; 0x78uy; 0x74uy; 0x24uy; 0x0auy; 0xeduy; 0x7buy; 0xdbuy; 0xa4uy; 0x24uy; 0x0buy; 0xb9uy; 0x7euy; 0x5duy; 0xffuy; 0xdeuy; 0xb1uy; 0xefuy; 0x61uy; 0x5auy; 0x45uy; 0x33uy; 0xf6uy; 0x17uy; 0x07uy; 0x08uy; 0x98uy; 0x83uy; 0x92uy; 0x0fuy; 0x23uy; 0x6duy; 0xe6uy; 0xaauy; 0x17uy; 0x54uy; 0xaduy; 0x6auy; 0xc8uy; 0xdbuy; 0x26uy; 0xbeuy; 0xb8uy; 0xb6uy; 0x08uy; 0xfauy; 0x68uy; 0xf1uy; 0xd7uy; 0x79uy; 0x6fuy; 0x18uy; 0xb4uy; 0x9euy; 0x2duy; 0x3fuy; 0x1buy; 0x64uy; 0xafuy; 0x8duy; 0x06uy; 0x0euy; 0x49uy; 0x28uy; 0xe0uy; 0x5duy; 0x45uy; 0x68uy; 0x13uy; 0x87uy; 0xfauy; 0xdeuy; 0x40uy; 0x7buy; 0xd2uy; 0xc3uy; 0x94uy; 0xd5uy; 0xe1uy; 0xd9uy; 0xc2uy; 0xafuy; 0x55uy; 0x89uy; 0xebuy; 0xb4uy; 0x12uy; 0x59uy; 0xa8uy; 0xd4uy; 0xc5uy; 0x29uy; 0x66uy; 0x38uy; 0xe6uy; 0xacuy; 0x22uy; 0x22uy; 0xd9uy; 0x64uy; 0x9buy; 0x34uy; 0x0auy; 0x32uy; 0x9fuy; 0xc2uy; 0xbfuy; 0x17uy; 0x6cuy; 0x3fuy; 0x71uy; 0x7auy; 0x38uy; 0x6buy; 0x98uy; 0xfbuy; 0x49uy; 0x36uy; 0x89uy; 0xc9uy; 0xe2uy; 0xd6uy; 0xc7uy; 0x5duy; 0xd0uy; 0x69uy; 0x5fuy; 0x23uy; 0x35uy; 0xc9uy; 0x30uy; 0xe2uy; 0xfduy; 0x44uy; 0x58uy; 0x39uy; 0xd7uy; 0x97uy; 0xfbuy; 0x5cuy; 0x00uy; 0xd5uy; 0x4fuy; 0x7auy; 0x1auy; 0x95uy; 0x8buy; 0x62uy; 0x4buy; 0xceuy; 0xe5uy; 0x91uy; 0x21uy; 0x7buy; 0x30uy; 0x00uy; 0xd6uy; 0xdduy; 0x6duy; 0x02uy; 0x86uy; 0x49uy; 0x0fuy; 0x3cuy; 0x1auy; 0x27uy; 0x3cuy; 0xd3uy; 0x0euy; 0x71uy; 0xf2uy; 0xffuy; 0xf5uy; 0x2fuy; 0x87uy; 0xacuy; 0x67uy; 0x59uy; 0x81uy; 0xa3uy; 0xf7uy; 0xf8uy; 0xd6uy; 0x11uy; 0x0cuy; 0x84uy; 0xa9uy; 0x03uy; 0xeeuy; 0x2auy; 0xc4uy; 0xf3uy; 0x22uy; 0xabuy; 0x7cuy; 0xe2uy; 0x25uy; 0xf5uy; 0x67uy; 0xa3uy; 0xe4uy; 0x11uy; 0xe0uy; 0x59uy; 0xb3uy; 0xcauy; 0x87uy; 0xa0uy; 0xaeuy; 0xc9uy; 0xa6uy; 0x62uy; 0x1buy; 0x6euy; 0x4duy; 0x02uy; 0x6buy; 0x07uy; 0x9duy; 0xfduy; 0xd0uy; 0x92uy; 0x06uy; 0xe1uy; 0xb2uy; 0x9auy; 0x4auy; 0x1fuy; 0x1fuy; 0x13uy; 0x49uy; 0x99uy; 0x97uy; 0x08uy; 0xdeuy; 0x7fuy; 0x98uy; 0xafuy; 0x51uy; 0x98uy; 0xeeuy; 0x2cuy; 0xcbuy; 0xf0uy; 0x0buy; 0xc6uy; 0xb6uy; 0xb7uy; 0x2duy; 0x9auy; 0xb1uy; 0xacuy; 0xa6uy; 0xe3uy; 0x15uy; 0x77uy; 0x9duy; 0x6buy; 0x1auy; 0xe4uy; 0xfcuy; 0x8buy; 0xf2uy; 0x17uy; 0x59uy; 0x08uy; 0x04uy; 0x58uy; 0x81uy; 0x9duy; 0x1buy; 0x1buy; 0x69uy; 0x55uy; 0xc2uy; 0xb4uy; 0x3cuy; 0x1fuy; 0x50uy; 0xf1uy; 0x7fuy; 0x77uy; 0x90uy; 0x4cuy; 0x66uy; 0x40uy; 0x5auy; 0xc0uy; 0x33uy; 0x1fuy; 0xcbuy; 0x05uy; 0x6duy; 0x5cuy; 0x06uy; 0x87uy; 0x52uy; 0xa2uy; 0x8fuy; 0x26uy; 0xd5uy; 0x4fuy; ] in
assert_norm (List.Tot.length l = 1024);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input9_len: (x:UInt32.t { UInt32.v x = B.length input9 }) =
1024ul
let output9: (b: B.buffer UInt8.t { B.length b = 1040 /\ B.recallable b }) =
[@inline_let] let l = [ 0xe5uy; 0x26uy; 0xa4uy; 0x3duy; 0xbduy; 0x33uy; 0xd0uy; 0x4buy; 0x6fuy; 0x05uy; 0xa7uy; 0x6euy; 0x12uy; 0x7auy; 0xd2uy; 0x74uy; 0xa6uy; 0xdduy; 0xbduy; 0x95uy; 0xebuy; 0xf9uy; 0xa4uy; 0xf1uy; 0x59uy; 0x93uy; 0x91uy; 0x70uy; 0xd9uy; 0xfeuy; 0x9auy; 0xcduy; 0x53uy; 0x1fuy; 0x3auy; 0xabuy; 0xa6uy; 0x7cuy; 0x9fuy; 0xa6uy; 0x9euy; 0xbduy; 0x99uy; 0xd9uy; 0xb5uy; 0x97uy; 0x44uy; 0xd5uy; 0x14uy; 0x48uy; 0x4duy; 0x9duy; 0xc0uy; 0xd0uy; 0x05uy; 0x96uy; 0xebuy; 0x4cuy; 0x78uy; 0x55uy; 0x09uy; 0x08uy; 0x01uy; 0x02uy; 0x30uy; 0x90uy; 0x7buy; 0x96uy; 0x7auy; 0x7buy; 0x5fuy; 0x30uy; 0x41uy; 0x24uy; 0xceuy; 0x68uy; 0x61uy; 0x49uy; 0x86uy; 0x57uy; 0x82uy; 0xdduy; 0x53uy; 0x1cuy; 0x51uy; 0x28uy; 0x2buy; 0x53uy; 0x6euy; 0x2duy; 0xc2uy; 0x20uy; 0x4cuy; 0xdduy; 0x8fuy; 0x65uy; 0x10uy; 0x20uy; 0x50uy; 0xdduy; 0x9duy; 0x50uy; 0xe5uy; 0x71uy; 0x40uy; 0x53uy; 0x69uy; 0xfcuy; 0x77uy; 0x48uy; 0x11uy; 0xb9uy; 0xdeuy; 0xa4uy; 0x8duy; 0x58uy; 0xe4uy; 0xa6uy; 0x1auy; 0x18uy; 0x47uy; 0x81uy; 0x7euy; 0xfcuy; 0xdduy; 0xf6uy; 0xefuy; 0xceuy; 0x2fuy; 0x43uy; 0x68uy; 0xd6uy; 0x06uy; 0xe2uy; 0x74uy; 0x6auy; 0xaduy; 0x90uy; 0xf5uy; 0x37uy; 0xf3uy; 0x3duy; 0x82uy; 0x69uy; 0x40uy; 0xe9uy; 0x6buy; 0xa7uy; 0x3duy; 0xa8uy; 0x1euy; 0xd2uy; 0x02uy; 0x7cuy; 0xb7uy; 0x9buy; 0xe4uy; 0xdauy; 0x8fuy; 0x95uy; 0x06uy; 0xc5uy; 0xdfuy; 0x73uy; 0xa3uy; 0x20uy; 0x9auy; 0x49uy; 0xdeuy; 0x9cuy; 0xbcuy; 0xeeuy; 0x14uy; 0x3fuy; 0x81uy; 0x5euy; 0xf8uy; 0x3buy; 0x59uy; 0x3cuy; 0xe1uy; 0x68uy; 0x12uy; 0x5auy; 0x3auy; 0x76uy; 0x3auy; 0x3fuy; 0xf7uy; 0x87uy; 0x33uy; 0x0auy; 0x01uy; 0xb8uy; 0xd4uy; 0xeduy; 0xb6uy; 0xbeuy; 0x94uy; 0x5euy; 0x70uy; 0x40uy; 0x56uy; 0x67uy; 0x1fuy; 0x50uy; 0x44uy; 0x19uy; 0xceuy; 0x82uy; 0x70uy; 0x10uy; 0x87uy; 0x13uy; 0x20uy; 0x0buy; 0x4cuy; 0x5auy; 0xb6uy; 0xf6uy; 0xa7uy; 0xaeuy; 0x81uy; 0x75uy; 0x01uy; 0x81uy; 0xe6uy; 0x4buy; 0x57uy; 0x7cuy; 0xdduy; 0x6duy; 0xf8uy; 0x1cuy; 0x29uy; 0x32uy; 0xf7uy; 0xdauy; 0x3cuy; 0x2duy; 0xf8uy; 0x9buy; 0x25uy; 0x6euy; 0x00uy; 0xb4uy; 0xf7uy; 0x2fuy; 0xf7uy; 0x04uy; 0xf7uy; 0xa1uy; 0x56uy; 0xacuy; 0x4fuy; 0x1auy; 0x64uy; 0xb8uy; 0x47uy; 0x55uy; 0x18uy; 0x7buy; 0x07uy; 0x4duy; 0xbduy; 0x47uy; 0x24uy; 0x80uy; 0x5duy; 0xa2uy; 0x70uy; 0xc5uy; 0xdduy; 0x8euy; 0x82uy; 0xd4uy; 0xebuy; 0xecuy; 0xb2uy; 0x0cuy; 0x39uy; 0xd2uy; 0x97uy; 0xc1uy; 0xcbuy; 0xebuy; 0xf4uy; 0x77uy; 0x59uy; 0xb4uy; 0x87uy; 0xefuy; 0xcbuy; 0x43uy; 0x2duy; 0x46uy; 0x54uy; 0xd1uy; 0xa7uy; 0xd7uy; 0x15uy; 0x99uy; 0x0auy; 0x43uy; 0xa1uy; 0xe0uy; 0x99uy; 0x33uy; 0x71uy; 0xc1uy; 0xeduy; 0xfeuy; 0x72uy; 0x46uy; 0x33uy; 0x8euy; 0x91uy; 0x08uy; 0x9fuy; 0xc8uy; 0x2euy; 0xcauy; 0xfauy; 0xdcuy; 0x59uy; 0xd5uy; 0xc3uy; 0x76uy; 0x84uy; 0x9fuy; 0xa3uy; 0x37uy; 0x68uy; 0xc3uy; 0xf0uy; 0x47uy; 0x2cuy; 0x68uy; 0xdbuy; 0x5euy; 0xc3uy; 0x49uy; 0x4cuy; 0xe8uy; 0x92uy; 0x85uy; 0xe2uy; 0x23uy; 0xd3uy; 0x3fuy; 0xaduy; 0x32uy; 0xe5uy; 0x2buy; 0x82uy; 0xd7uy; 0x8fuy; 0x99uy; 0x0auy; 0x59uy; 0x5cuy; 0x45uy; 0xd9uy; 0xb4uy; 0x51uy; 0x52uy; 0xc2uy; 0xaeuy; 0xbfuy; 0x80uy; 0xcfuy; 0xc9uy; 0xc9uy; 0x51uy; 0x24uy; 0x2auy; 0x3buy; 0x3auy; 0x4duy; 0xaeuy; 0xebuy; 0xbduy; 0x22uy; 0xc3uy; 0x0euy; 0x0fuy; 0x59uy; 0x25uy; 0x92uy; 0x17uy; 0xe9uy; 0x74uy; 0xc7uy; 0x8buy; 0x70uy; 0x70uy; 0x36uy; 0x55uy; 0x95uy; 0x75uy; 0x4buy; 0xaduy; 0x61uy; 0x2buy; 0x09uy; 0xbcuy; 0x82uy; 0xf2uy; 0x6euy; 0x94uy; 0x43uy; 0xaeuy; 0xc3uy; 0xd5uy; 0xcduy; 0x8euy; 0xfeuy; 0x5buy; 0x9auy; 0x88uy; 0x43uy; 0x01uy; 0x75uy; 0xb2uy; 0x23uy; 0x09uy; 0xf7uy; 0x89uy; 0x83uy; 0xe7uy; 0xfauy; 0xf9uy; 0xb4uy; 0x9buy; 0xf8uy; 0xefuy; 0xbduy; 0x1cuy; 0x92uy; 0xc1uy; 0xdauy; 0x7euy; 0xfeuy; 0x05uy; 0xbauy; 0x5auy; 0xcduy; 0x07uy; 0x6auy; 0x78uy; 0x9euy; 0x5duy; 0xfbuy; 0x11uy; 0x2fuy; 0x79uy; 0x38uy; 0xb6uy; 0xc2uy; 0x5buy; 0x6buy; 0x51uy; 0xb4uy; 0x71uy; 0xdduy; 0xf7uy; 0x2auy; 0xe4uy; 0xf4uy; 0x72uy; 0x76uy; 0xaduy; 0xc2uy; 0xdduy; 0x64uy; 0x5duy; 0x79uy; 0xb6uy; 0xf5uy; 0x7auy; 0x77uy; 0x20uy; 0x05uy; 0x3duy; 0x30uy; 0x06uy; 0xd4uy; 0x4cuy; 0x0auy; 0x2cuy; 0x98uy; 0x5auy; 0xb9uy; 0xd4uy; 0x98uy; 0xa9uy; 0x3fuy; 0xc6uy; 0x12uy; 0xeauy; 0x3buy; 0x4buy; 0xc5uy; 0x79uy; 0x64uy; 0x63uy; 0x6buy; 0x09uy; 0x54uy; 0x3buy; 0x14uy; 0x27uy; 0xbauy; 0x99uy; 0x80uy; 0xc8uy; 0x72uy; 0xa8uy; 0x12uy; 0x90uy; 0x29uy; 0xbauy; 0x40uy; 0x54uy; 0x97uy; 0x2buy; 0x7buy; 0xfeuy; 0xebuy; 0xcduy; 0x01uy; 0x05uy; 0x44uy; 0x72uy; 0xdbuy; 0x99uy; 0xe4uy; 0x61uy; 0xc9uy; 0x69uy; 0xd6uy; 0xb9uy; 0x28uy; 0xd1uy; 0x05uy; 0x3euy; 0xf9uy; 0x0buy; 0x49uy; 0x0auy; 0x49uy; 0xe9uy; 0x8duy; 0x0euy; 0xa7uy; 0x4auy; 0x0fuy; 0xafuy; 0x32uy; 0xd0uy; 0xe0uy; 0xb2uy; 0x3auy; 0x55uy; 0x58uy; 0xfeuy; 0x5cuy; 0x28uy; 0x70uy; 0x51uy; 0x23uy; 0xb0uy; 0x7buy; 0x6auy; 0x5fuy; 0x1euy; 0xb8uy; 0x17uy; 0xd7uy; 0x94uy; 0x15uy; 0x8fuy; 0xeeuy; 0x20uy; 0xc7uy; 0x42uy; 0x25uy; 0x3euy; 0x9auy; 0x14uy; 0xd7uy; 0x60uy; 0x72uy; 0x39uy; 0x47uy; 0x48uy; 0xa9uy; 0xfeuy; 0xdduy; 0x47uy; 0x0auy; 0xb1uy; 0xe6uy; 0x60uy; 0x28uy; 0x8cuy; 0x11uy; 0x68uy; 0xe1uy; 0xffuy; 0xd7uy; 0xceuy; 0xc8uy; 0xbeuy; 0xb3uy; 0xfeuy; 0x27uy; 0x30uy; 0x09uy; 0x70uy; 0xd7uy; 0xfauy; 0x02uy; 0x33uy; 0x3auy; 0x61uy; 0x2euy; 0xc7uy; 0xffuy; 0xa4uy; 0x2auy; 0xa8uy; 0x6euy; 0xb4uy; 0x79uy; 0x35uy; 0x6duy; 0x4cuy; 0x1euy; 0x38uy; 0xf8uy; 0xeeuy; 0xd4uy; 0x84uy; 0x4euy; 0x6euy; 0x28uy; 0xa7uy; 0xceuy; 0xc8uy; 0xc1uy; 0xcfuy; 0x80uy; 0x05uy; 0xf3uy; 0x04uy; 0xefuy; 0xc8uy; 0x18uy; 0x28uy; 0x2euy; 0x8duy; 0x5euy; 0x0cuy; 0xdfuy; 0xb8uy; 0x5fuy; 0x96uy; 0xe8uy; 0xc6uy; 0x9cuy; 0x2fuy; 0xe5uy; 0xa6uy; 0x44uy; 0xd7uy; 0xe7uy; 0x99uy; 0x44uy; 0x0cuy; 0xecuy; 0xd7uy; 0x05uy; 0x60uy; 0x97uy; 0xbbuy; 0x74uy; 0x77uy; 0x58uy; 0xd5uy; 0xbbuy; 0x48uy; 0xdeuy; 0x5auy; 0xb2uy; 0x54uy; 0x7fuy; 0x0euy; 0x46uy; 0x70uy; 0x6auy; 0x6fuy; 0x78uy; 0xa5uy; 0x08uy; 0x89uy; 0x05uy; 0x4euy; 0x7euy; 0xa0uy; 0x69uy; 0xb4uy; 0x40uy; 0x60uy; 0x55uy; 0x77uy; 0x75uy; 0x9buy; 0x19uy; 0xf2uy; 0xd5uy; 0x13uy; 0x80uy; 0x77uy; 0xf9uy; 0x4buy; 0x3fuy; 0x1euy; 0xeeuy; 0xe6uy; 0x76uy; 0x84uy; 0x7buy; 0x8cuy; 0xe5uy; 0x27uy; 0xa8uy; 0x0auy; 0x91uy; 0x01uy; 0x68uy; 0x71uy; 0x8auy; 0x3fuy; 0x06uy; 0xabuy; 0xf6uy; 0xa9uy; 0xa5uy; 0xe6uy; 0x72uy; 0x92uy; 0xe4uy; 0x67uy; 0xe2uy; 0xa2uy; 0x46uy; 0x35uy; 0x84uy; 0x55uy; 0x7duy; 0xcauy; 0xa8uy; 0x85uy; 0xd0uy; 0xf1uy; 0x3fuy; 0xbeuy; 0xd7uy; 0x34uy; 0x64uy; 0xfcuy; 0xaeuy; 0xe3uy; 0xe4uy; 0x04uy; 0x9fuy; 0x66uy; 0x02uy; 0xb9uy; 0x88uy; 0x10uy; 0xd9uy; 0xc4uy; 0x4cuy; 0x31uy; 0x43uy; 0x7auy; 0x93uy; 0xe2uy; 0x9buy; 0x56uy; 0x43uy; 0x84uy; 0xdcuy; 0xdcuy; 0xdeuy; 0x1duy; 0xa4uy; 0x02uy; 0x0euy; 0xc2uy; 0xefuy; 0xc3uy; 0xf8uy; 0x78uy; 0xd1uy; 0xb2uy; 0x6buy; 0x63uy; 0x18uy; 0xc9uy; 0xa9uy; 0xe5uy; 0x72uy; 0xd8uy; 0xf3uy; 0xb9uy; 0xd1uy; 0x8auy; 0xc7uy; 0x1auy; 0x02uy; 0x27uy; 0x20uy; 0x77uy; 0x10uy; 0xe5uy; 0xc8uy; 0xd4uy; 0x4auy; 0x47uy; 0xe5uy; 0xdfuy; 0x5fuy; 0x01uy; 0xaauy; 0xb0uy; 0xd4uy; 0x10uy; 0xbbuy; 0x69uy; 0xe3uy; 0x36uy; 0xc8uy; 0xe1uy; 0x3duy; 0x43uy; 0xfbuy; 0x86uy; 0xcduy; 0xccuy; 0xbfuy; 0xf4uy; 0x88uy; 0xe0uy; 0x20uy; 0xcauy; 0xb7uy; 0x1buy; 0xf1uy; 0x2fuy; 0x5cuy; 0xeeuy; 0xd4uy; 0xd3uy; 0xa3uy; 0xccuy; 0xa4uy; 0x1euy; 0x1cuy; 0x47uy; 0xfbuy; 0xbfuy; 0xfcuy; 0xa2uy; 0x41uy; 0x55uy; 0x9duy; 0xf6uy; 0x5auy; 0x5euy; 0x65uy; 0x32uy; 0x34uy; 0x7buy; 0x52uy; 0x8duy; 0xd5uy; 0xd0uy; 0x20uy; 0x60uy; 0x03uy; 0xabuy; 0x3fuy; 0x8cuy; 0xd4uy; 0x21uy; 0xeauy; 0x2auy; 0xd9uy; 0xc4uy; 0xd0uy; 0xd3uy; 0x65uy; 0xd8uy; 0x7auy; 0x13uy; 0x28uy; 0x62uy; 0x32uy; 0x4buy; 0x2cuy; 0x87uy; 0x93uy; 0xa8uy; 0xb4uy; 0x52uy; 0x45uy; 0x09uy; 0x44uy; 0xecuy; 0xecuy; 0xc3uy; 0x17uy; 0xdbuy; 0x9auy; 0x4duy; 0x5cuy; 0xa9uy; 0x11uy; 0xd4uy; 0x7duy; 0xafuy; 0x9euy; 0xf1uy; 0x2duy; 0xb2uy; 0x66uy; 0xc5uy; 0x1duy; 0xeduy; 0xb7uy; 0xcduy; 0x0buy; 0x25uy; 0x5euy; 0x30uy; 0x47uy; 0x3fuy; 0x40uy; 0xf4uy; 0xa1uy; 0xa0uy; 0x00uy; 0x94uy; 0x10uy; 0xc5uy; 0x6auy; 0x63uy; 0x1auy; 0xd5uy; 0x88uy; 0x92uy; 0x8euy; 0x82uy; 0x39uy; 0x87uy; 0x3cuy; 0x78uy; 0x65uy; 0x58uy; 0x42uy; 0x75uy; 0x5buy; 0xdduy; 0x77uy; 0x3euy; 0x09uy; 0x4euy; 0x76uy; 0x5buy; 0xe6uy; 0x0euy; 0x4duy; 0x38uy; 0xb2uy; 0xc0uy; 0xb8uy; 0x95uy; 0x01uy; 0x7auy; 0x10uy; 0xe0uy; 0xfbuy; 0x07uy; 0xf2uy; 0xabuy; 0x2duy; 0x8cuy; 0x32uy; 0xeduy; 0x2buy; 0xc0uy; 0x46uy; 0xc2uy; 0xf5uy; 0x38uy; 0x83uy; 0xf0uy; 0x17uy; 0xecuy; 0xc1uy; 0x20uy; 0x6auy; 0x9auy; 0x0buy; 0x00uy; 0xa0uy; 0x98uy; 0x22uy; 0x50uy; 0x23uy; 0xd5uy; 0x80uy; 0x6buy; 0xf6uy; 0x1fuy; 0xc3uy; 0xccuy; 0x97uy; 0xc9uy; 0x24uy; 0x9fuy; 0xf3uy; 0xafuy; 0x43uy; 0x14uy; 0xd5uy; 0xa0uy; ] in
assert_norm (List.Tot.length l = 1040);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output9_len: (x:UInt32.t { UInt32.v x = B.length output9 }) =
1040ul
let key10: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x35uy; 0x4euy; 0xb5uy; 0x70uy; 0x50uy; 0x42uy; 0x8auy; 0x85uy; 0xf2uy; 0xfbuy; 0xeduy; 0x7buy; 0xd0uy; 0x9euy; 0x97uy; 0xcauy; 0xfauy; 0x98uy; 0x66uy; 0x63uy; 0xeeuy; 0x37uy; 0xccuy; 0x52uy; 0xfeuy; 0xd1uy; 0xdfuy; 0x95uy; 0x15uy; 0x34uy; 0x29uy; 0x38uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key10_len: (x:UInt32.t { UInt32.v x = B.length key10 }) =
32ul
let nonce10: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xfduy; 0x87uy; 0xd4uy; 0xd8uy; 0x62uy; 0xfduy; 0xecuy; 0xaauy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce10_len: (x:UInt32.t { UInt32.v x = B.length nonce10 }) =
12ul
let aad10: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) =
[@inline_let] let l = [ 0xd6uy; 0x31uy; 0xdauy; 0x5duy; 0x42uy; 0x5euy; 0xd7uy; ] in
assert_norm (List.Tot.length l = 7);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad10_len: (x:UInt32.t { UInt32.v x = B.length aad10 }) =
7ul
let input10: (b: B.buffer UInt8.t { B.length b = 1933 /\ B.recallable b /\ B.disjoint b aad10 }) =
B.recall aad10;[@inline_let] let l = [ 0x7auy; 0x57uy; 0xf2uy; 0xc7uy; 0x06uy; 0x3fuy; 0x50uy; 0x7buy; 0x36uy; 0x1auy; 0x66uy; 0x5cuy; 0xb9uy; 0x0euy; 0x5euy; 0x3buy; 0x45uy; 0x60uy; 0xbeuy; 0x9auy; 0x31uy; 0x9fuy; 0xffuy; 0x5duy; 0x66uy; 0x34uy; 0xb4uy; 0xdcuy; 0xfbuy; 0x9duy; 0x8euy; 0xeeuy; 0x6auy; 0x33uy; 0xa4uy; 0x07uy; 0x3cuy; 0xf9uy; 0x4cuy; 0x30uy; 0xa1uy; 0x24uy; 0x52uy; 0xf9uy; 0x50uy; 0x46uy; 0x88uy; 0x20uy; 0x02uy; 0x32uy; 0x3auy; 0x0euy; 0x99uy; 0x63uy; 0xafuy; 0x1fuy; 0x15uy; 0x28uy; 0x2auy; 0x05uy; 0xffuy; 0x57uy; 0x59uy; 0x5euy; 0x18uy; 0xa1uy; 0x1fuy; 0xd0uy; 0x92uy; 0x5cuy; 0x88uy; 0x66uy; 0x1buy; 0x00uy; 0x64uy; 0xa5uy; 0x93uy; 0x8duy; 0x06uy; 0x46uy; 0xb0uy; 0x64uy; 0x8buy; 0x8buy; 0xefuy; 0x99uy; 0x05uy; 0x35uy; 0x85uy; 0xb3uy; 0xf3uy; 0x33uy; 0xbbuy; 0xecuy; 0x66uy; 0xb6uy; 0x3duy; 0x57uy; 0x42uy; 0xe3uy; 0xb4uy; 0xc6uy; 0xaauy; 0xb0uy; 0x41uy; 0x2auy; 0xb9uy; 0x59uy; 0xa9uy; 0xf6uy; 0x3euy; 0x15uy; 0x26uy; 0x12uy; 0x03uy; 0x21uy; 0x4cuy; 0x74uy; 0x43uy; 0x13uy; 0x2auy; 0x03uy; 0x27uy; 0x09uy; 0xb4uy; 0xfbuy; 0xe7uy; 0xb7uy; 0x40uy; 0xffuy; 0x5euy; 0xceuy; 0x48uy; 0x9auy; 0x60uy; 0xe3uy; 0x8buy; 0x80uy; 0x8cuy; 0x38uy; 0x2duy; 0xcbuy; 0x93uy; 0x37uy; 0x74uy; 0x05uy; 0x52uy; 0x6fuy; 0x73uy; 0x3euy; 0xc3uy; 0xbcuy; 0xcauy; 0x72uy; 0x0auy; 0xebuy; 0xf1uy; 0x3buy; 0xa0uy; 0x95uy; 0xdcuy; 0x8auy; 0xc4uy; 0xa9uy; 0xdcuy; 0xcauy; 0x44uy; 0xd8uy; 0x08uy; 0x63uy; 0x6auy; 0x36uy; 0xd3uy; 0x3cuy; 0xb8uy; 0xacuy; 0x46uy; 0x7duy; 0xfduy; 0xaauy; 0xebuy; 0x3euy; 0x0fuy; 0x45uy; 0x8fuy; 0x49uy; 0xdauy; 0x2buy; 0xf2uy; 0x12uy; 0xbduy; 0xafuy; 0x67uy; 0x8auy; 0x63uy; 0x48uy; 0x4buy; 0x55uy; 0x5fuy; 0x6duy; 0x8cuy; 0xb9uy; 0x76uy; 0x34uy; 0x84uy; 0xaeuy; 0xc2uy; 0xfcuy; 0x52uy; 0x64uy; 0x82uy; 0xf7uy; 0xb0uy; 0x06uy; 0xf0uy; 0x45uy; 0x73uy; 0x12uy; 0x50uy; 0x30uy; 0x72uy; 0xeauy; 0x78uy; 0x9auy; 0xa8uy; 0xafuy; 0xb5uy; 0xe3uy; 0xbbuy; 0x77uy; 0x52uy; 0xecuy; 0x59uy; 0x84uy; 0xbfuy; 0x6buy; 0x8fuy; 0xceuy; 0x86uy; 0x5euy; 0x1fuy; 0x23uy; 0xe9uy; 0xfbuy; 0x08uy; 0x86uy; 0xf7uy; 0x10uy; 0xb9uy; 0xf2uy; 0x44uy; 0x96uy; 0x44uy; 0x63uy; 0xa9uy; 0xa8uy; 0x78uy; 0x00uy; 0x23uy; 0xd6uy; 0xc7uy; 0xe7uy; 0x6euy; 0x66uy; 0x4fuy; 0xccuy; 0xeeuy; 0x15uy; 0xb3uy; 0xbduy; 0x1duy; 0xa0uy; 0xe5uy; 0x9cuy; 0x1buy; 0x24uy; 0x2cuy; 0x4duy; 0x3cuy; 0x62uy; 0x35uy; 0x9cuy; 0x88uy; 0x59uy; 0x09uy; 0xdduy; 0x82uy; 0x1buy; 0xcfuy; 0x0auy; 0x83uy; 0x6buy; 0x3fuy; 0xaeuy; 0x03uy; 0xc4uy; 0xb4uy; 0xdduy; 0x7euy; 0x5buy; 0x28uy; 0x76uy; 0x25uy; 0x96uy; 0xd9uy; 0xc9uy; 0x9duy; 0x5fuy; 0x86uy; 0xfauy; 0xf6uy; 0xd7uy; 0xd2uy; 0xe6uy; 0x76uy; 0x1duy; 0x0fuy; 0xa1uy; 0xdcuy; 0x74uy; 0x05uy; 0x1buy; 0x1duy; 0xe0uy; 0xcduy; 0x16uy; 0xb0uy; 0xa8uy; 0x8auy; 0x34uy; 0x7buy; 0x15uy; 0x11uy; 0x77uy; 0xe5uy; 0x7buy; 0x7euy; 0x20uy; 0xf7uy; 0xdauy; 0x38uy; 0xdauy; 0xceuy; 0x70uy; 0xe9uy; 0xf5uy; 0x6cuy; 0xd9uy; 0xbeuy; 0x0cuy; 0x4cuy; 0x95uy; 0x4cuy; 0xc2uy; 0x9buy; 0x34uy; 0x55uy; 0x55uy; 0xe1uy; 0xf3uy; 0x46uy; 0x8euy; 0x48uy; 0x74uy; 0x14uy; 0x4fuy; 0x9duy; 0xc9uy; 0xf5uy; 0xe8uy; 0x1auy; 0xf0uy; 0x11uy; 0x4auy; 0xc1uy; 0x8duy; 0xe0uy; 0x93uy; 0xa0uy; 0xbeuy; 0x09uy; 0x1cuy; 0x2buy; 0x4euy; 0x0fuy; 0xb2uy; 0x87uy; 0x8buy; 0x84uy; 0xfeuy; 0x92uy; 0x32uy; 0x14uy; 0xd7uy; 0x93uy; 0xdfuy; 0xe7uy; 0x44uy; 0xbcuy; 0xc5uy; 0xaeuy; 0x53uy; 0x69uy; 0xd8uy; 0xb3uy; 0x79uy; 0x37uy; 0x80uy; 0xe3uy; 0x17uy; 0x5cuy; 0xecuy; 0x53uy; 0x00uy; 0x9auy; 0xe3uy; 0x8euy; 0xdcuy; 0x38uy; 0xb8uy; 0x66uy; 0xf0uy; 0xd3uy; 0xaduy; 0x1duy; 0x02uy; 0x96uy; 0x86uy; 0x3euy; 0x9duy; 0x3buy; 0x5duy; 0xa5uy; 0x7fuy; 0x21uy; 0x10uy; 0xf1uy; 0x1fuy; 0x13uy; 0x20uy; 0xf9uy; 0x57uy; 0x87uy; 0x20uy; 0xf5uy; 0x5fuy; 0xf1uy; 0x17uy; 0x48uy; 0x0auy; 0x51uy; 0x5auy; 0xcduy; 0x19uy; 0x03uy; 0xa6uy; 0x5auy; 0xd1uy; 0x12uy; 0x97uy; 0xe9uy; 0x48uy; 0xe2uy; 0x1duy; 0x83uy; 0x75uy; 0x50uy; 0xd9uy; 0x75uy; 0x7duy; 0x6auy; 0x82uy; 0xa1uy; 0xf9uy; 0x4euy; 0x54uy; 0x87uy; 0x89uy; 0xc9uy; 0x0cuy; 0xb7uy; 0x5buy; 0x6auy; 0x91uy; 0xc1uy; 0x9cuy; 0xb2uy; 0xa9uy; 0xdcuy; 0x9auy; 0xa4uy; 0x49uy; 0x0auy; 0x6duy; 0x0duy; 0xbbuy; 0xdeuy; 0x86uy; 0x44uy; 0xdduy; 0x5duy; 0x89uy; 0x2buy; 0x96uy; 0x0fuy; 0x23uy; 0x95uy; 0xaduy; 0xccuy; 0xa2uy; 0xb3uy; 0xb9uy; 0x7euy; 0x74uy; 0x38uy; 0xbauy; 0x9fuy; 0x73uy; 0xaeuy; 0x5fuy; 0xf8uy; 0x68uy; 0xa2uy; 0xe0uy; 0xa9uy; 0xceuy; 0xbduy; 0x40uy; 0xd4uy; 0x4cuy; 0x6buy; 0xd2uy; 0x56uy; 0x62uy; 0xb0uy; 0xccuy; 0x63uy; 0x7euy; 0x5buy; 0xd3uy; 0xaeuy; 0xd1uy; 0x75uy; 0xceuy; 0xbbuy; 0xb4uy; 0x5buy; 0xa8uy; 0xf8uy; 0xb4uy; 0xacuy; 0x71uy; 0x75uy; 0xaauy; 0xc9uy; 0x9fuy; 0xbbuy; 0x6cuy; 0xaduy; 0x0fuy; 0x55uy; 0x5duy; 0xe8uy; 0x85uy; 0x7duy; 0xf9uy; 0x21uy; 0x35uy; 0xeauy; 0x92uy; 0x85uy; 0x2buy; 0x00uy; 0xecuy; 0x84uy; 0x90uy; 0x0auy; 0x63uy; 0x96uy; 0xe4uy; 0x6buy; 0xa9uy; 0x77uy; 0xb8uy; 0x91uy; 0xf8uy; 0x46uy; 0x15uy; 0x72uy; 0x63uy; 0x70uy; 0x01uy; 0x40uy; 0xa3uy; 0xa5uy; 0x76uy; 0x62uy; 0x2buy; 0xbfuy; 0xf1uy; 0xe5uy; 0x8duy; 0x9fuy; 0xa3uy; 0xfauy; 0x9buy; 0x03uy; 0xbeuy; 0xfeuy; 0x65uy; 0x6fuy; 0xa2uy; 0x29uy; 0x0duy; 0x54uy; 0xb4uy; 0x71uy; 0xceuy; 0xa9uy; 0xd6uy; 0x3duy; 0x88uy; 0xf9uy; 0xafuy; 0x6buy; 0xa8uy; 0x9euy; 0xf4uy; 0x16uy; 0x96uy; 0x36uy; 0xb9uy; 0x00uy; 0xdcuy; 0x10uy; 0xabuy; 0xb5uy; 0x08uy; 0x31uy; 0x1fuy; 0x00uy; 0xb1uy; 0x3cuy; 0xd9uy; 0x38uy; 0x3euy; 0xc6uy; 0x04uy; 0xa7uy; 0x4euy; 0xe8uy; 0xaeuy; 0xeduy; 0x98uy; 0xc2uy; 0xf7uy; 0xb9uy; 0x00uy; 0x5fuy; 0x8cuy; 0x60uy; 0xd1uy; 0xe5uy; 0x15uy; 0xf7uy; 0xaeuy; 0x1euy; 0x84uy; 0x88uy; 0xd1uy; 0xf6uy; 0xbcuy; 0x3auy; 0x89uy; 0x35uy; 0x22uy; 0x83uy; 0x7cuy; 0xcauy; 0xf0uy; 0x33uy; 0x82uy; 0x4cuy; 0x79uy; 0x3cuy; 0xfduy; 0xb1uy; 0xaeuy; 0x52uy; 0x62uy; 0x55uy; 0xd2uy; 0x41uy; 0x60uy; 0xc6uy; 0xbbuy; 0xfauy; 0x0euy; 0x59uy; 0xd6uy; 0xa8uy; 0xfeuy; 0x5duy; 0xeduy; 0x47uy; 0x3duy; 0xe0uy; 0xeauy; 0x1fuy; 0x6euy; 0x43uy; 0x51uy; 0xecuy; 0x10uy; 0x52uy; 0x56uy; 0x77uy; 0x42uy; 0x6buy; 0x52uy; 0x87uy; 0xd8uy; 0xecuy; 0xe0uy; 0xaauy; 0x76uy; 0xa5uy; 0x84uy; 0x2auy; 0x22uy; 0x24uy; 0xfduy; 0x92uy; 0x40uy; 0x88uy; 0xd5uy; 0x85uy; 0x1cuy; 0x1fuy; 0x6buy; 0x47uy; 0xa0uy; 0xc4uy; 0xe4uy; 0xefuy; 0xf4uy; 0xeauy; 0xd7uy; 0x59uy; 0xacuy; 0x2auy; 0x9euy; 0x8cuy; 0xfauy; 0x1fuy; 0x42uy; 0x08uy; 0xfeuy; 0x4fuy; 0x74uy; 0xa0uy; 0x26uy; 0xf5uy; 0xb3uy; 0x84uy; 0xf6uy; 0x58uy; 0x5fuy; 0x26uy; 0x66uy; 0x3euy; 0xd7uy; 0xe4uy; 0x22uy; 0x91uy; 0x13uy; 0xc8uy; 0xacuy; 0x25uy; 0x96uy; 0x23uy; 0xd8uy; 0x09uy; 0xeauy; 0x45uy; 0x75uy; 0x23uy; 0xb8uy; 0x5fuy; 0xc2uy; 0x90uy; 0x8buy; 0x09uy; 0xc4uy; 0xfcuy; 0x47uy; 0x6cuy; 0x6duy; 0x0auy; 0xefuy; 0x69uy; 0xa4uy; 0x38uy; 0x19uy; 0xcfuy; 0x7duy; 0xf9uy; 0x09uy; 0x73uy; 0x9buy; 0x60uy; 0x5auy; 0xf7uy; 0x37uy; 0xb5uy; 0xfeuy; 0x9fuy; 0xe3uy; 0x2buy; 0x4cuy; 0x0duy; 0x6euy; 0x19uy; 0xf1uy; 0xd6uy; 0xc0uy; 0x70uy; 0xf3uy; 0x9duy; 0x22uy; 0x3cuy; 0xf9uy; 0x49uy; 0xceuy; 0x30uy; 0x8euy; 0x44uy; 0xb5uy; 0x76uy; 0x15uy; 0x8fuy; 0x52uy; 0xfduy; 0xa5uy; 0x04uy; 0xb8uy; 0x55uy; 0x6auy; 0x36uy; 0x59uy; 0x7cuy; 0xc4uy; 0x48uy; 0xb8uy; 0xd7uy; 0xabuy; 0x05uy; 0x66uy; 0xe9uy; 0x5euy; 0x21uy; 0x6fuy; 0x6buy; 0x36uy; 0x29uy; 0xbbuy; 0xe9uy; 0xe3uy; 0xa2uy; 0x9auy; 0xa8uy; 0xcduy; 0x55uy; 0x25uy; 0x11uy; 0xbauy; 0x5auy; 0x58uy; 0xa0uy; 0xdeuy; 0xaeuy; 0x19uy; 0x2auy; 0x48uy; 0x5auy; 0xffuy; 0x36uy; 0xcduy; 0x6duy; 0x16uy; 0x7auy; 0x73uy; 0x38uy; 0x46uy; 0xe5uy; 0x47uy; 0x59uy; 0xc8uy; 0xa2uy; 0xf6uy; 0xe2uy; 0x6cuy; 0x83uy; 0xc5uy; 0x36uy; 0x2cuy; 0x83uy; 0x7duy; 0xb4uy; 0x01uy; 0x05uy; 0x69uy; 0xe7uy; 0xafuy; 0x5cuy; 0xc4uy; 0x64uy; 0x82uy; 0x12uy; 0x21uy; 0xefuy; 0xf7uy; 0xd1uy; 0x7duy; 0xb8uy; 0x8duy; 0x8cuy; 0x98uy; 0x7cuy; 0x5fuy; 0x7duy; 0x92uy; 0x88uy; 0xb9uy; 0x94uy; 0x07uy; 0x9cuy; 0xd8uy; 0xe9uy; 0x9cuy; 0x17uy; 0x38uy; 0xe3uy; 0x57uy; 0x6cuy; 0xe0uy; 0xdcuy; 0xa5uy; 0x92uy; 0x42uy; 0xb3uy; 0xbduy; 0x50uy; 0xa2uy; 0x7euy; 0xb5uy; 0xb1uy; 0x52uy; 0x72uy; 0x03uy; 0x97uy; 0xd8uy; 0xaauy; 0x9auy; 0x1euy; 0x75uy; 0x41uy; 0x11uy; 0xa3uy; 0x4fuy; 0xccuy; 0xd4uy; 0xe3uy; 0x73uy; 0xaduy; 0x96uy; 0xdcuy; 0x47uy; 0x41uy; 0x9fuy; 0xb0uy; 0xbeuy; 0x79uy; 0x91uy; 0xf5uy; 0xb6uy; 0x18uy; 0xfeuy; 0xc2uy; 0x83uy; 0x18uy; 0x7duy; 0x73uy; 0xd9uy; 0x4fuy; 0x83uy; 0x84uy; 0x03uy; 0xb3uy; 0xf0uy; 0x77uy; 0x66uy; 0x3duy; 0x83uy; 0x63uy; 0x2euy; 0x2cuy; 0xf9uy; 0xdduy; 0xa6uy; 0x1fuy; 0x89uy; 0x82uy; 0xb8uy; 0x23uy; 0x42uy; 0xebuy; 0xe2uy; 0xcauy; 0x70uy; 0x82uy; 0x61uy; 0x41uy; 0x0auy; 0x6duy; 0x5fuy; 0x75uy; 0xc5uy; 0xe2uy; 0xc4uy; 0x91uy; 0x18uy; 0x44uy; 0x22uy; 0xfauy; 0x34uy; 0x10uy; 0xf5uy; 0x20uy; 0xdcuy; 0xb7uy; 0xdduy; 0x2auy; 0x20uy; 0x77uy; 0xf5uy; 0xf9uy; 0xceuy; 0xdbuy; 0xa0uy; 0x0auy; 0x52uy; 0x2auy; 0x4euy; 0xdduy; 0xccuy; 0x97uy; 0xdfuy; 0x05uy; 0xe4uy; 0x5euy; 0xb7uy; 0xaauy; 0xf0uy; 0xe2uy; 0x80uy; 0xffuy; 0xbauy; 0x1auy; 0x0fuy; 0xacuy; 0xdfuy; 0x02uy; 0x32uy; 0xe6uy; 0xf7uy; 0xc7uy; 0x17uy; 0x13uy; 0xb7uy; 0xfcuy; 0x98uy; 0x48uy; 0x8cuy; 0x0duy; 0x82uy; 0xc9uy; 0x80uy; 0x7auy; 0xe2uy; 0x0auy; 0xc5uy; 0xb4uy; 0xdeuy; 0x7cuy; 0x3cuy; 0x79uy; 0x81uy; 0x0euy; 0x28uy; 0x65uy; 0x79uy; 0x67uy; 0x82uy; 0x69uy; 0x44uy; 0x66uy; 0x09uy; 0xf7uy; 0x16uy; 0x1auy; 0xf9uy; 0x7duy; 0x80uy; 0xa1uy; 0x79uy; 0x14uy; 0xa9uy; 0xc8uy; 0x20uy; 0xfbuy; 0xa2uy; 0x46uy; 0xbeuy; 0x08uy; 0x35uy; 0x17uy; 0x58uy; 0xc1uy; 0x1auy; 0xdauy; 0x2auy; 0x6buy; 0x2euy; 0x1euy; 0xe6uy; 0x27uy; 0x55uy; 0x7buy; 0x19uy; 0xe2uy; 0xfbuy; 0x64uy; 0xfcuy; 0x5euy; 0x15uy; 0x54uy; 0x3cuy; 0xe7uy; 0xc2uy; 0x11uy; 0x50uy; 0x30uy; 0xb8uy; 0x72uy; 0x03uy; 0x0buy; 0x1auy; 0x9fuy; 0x86uy; 0x27uy; 0x11uy; 0x5cuy; 0x06uy; 0x2buy; 0xbduy; 0x75uy; 0x1auy; 0x0auy; 0xdauy; 0x01uy; 0xfauy; 0x5cuy; 0x4auy; 0xc1uy; 0x80uy; 0x3auy; 0x6euy; 0x30uy; 0xc8uy; 0x2cuy; 0xebuy; 0x56uy; 0xecuy; 0x89uy; 0xfauy; 0x35uy; 0x7buy; 0xb2uy; 0xf0uy; 0x97uy; 0x08uy; 0x86uy; 0x53uy; 0xbeuy; 0xbduy; 0x40uy; 0x41uy; 0x38uy; 0x1cuy; 0xb4uy; 0x8buy; 0x79uy; 0x2euy; 0x18uy; 0x96uy; 0x94uy; 0xdeuy; 0xe8uy; 0xcauy; 0xe5uy; 0x9fuy; 0x92uy; 0x9fuy; 0x15uy; 0x5duy; 0x56uy; 0x60uy; 0x5cuy; 0x09uy; 0xf9uy; 0x16uy; 0xf4uy; 0x17uy; 0x0fuy; 0xf6uy; 0x4cuy; 0xdauy; 0xe6uy; 0x67uy; 0x89uy; 0x9fuy; 0xcauy; 0x6cuy; 0xe7uy; 0x9buy; 0x04uy; 0x62uy; 0x0euy; 0x26uy; 0xa6uy; 0x52uy; 0xbduy; 0x29uy; 0xffuy; 0xc7uy; 0xa4uy; 0x96uy; 0xe6uy; 0x6auy; 0x02uy; 0xa5uy; 0x2euy; 0x7buy; 0xfeuy; 0x97uy; 0x68uy; 0x3euy; 0x2euy; 0x5fuy; 0x3buy; 0x0fuy; 0x36uy; 0xd6uy; 0x98uy; 0x19uy; 0x59uy; 0x48uy; 0xd2uy; 0xc6uy; 0xe1uy; 0x55uy; 0x1auy; 0x6euy; 0xd6uy; 0xeduy; 0x2cuy; 0xbauy; 0xc3uy; 0x9euy; 0x64uy; 0xc9uy; 0x95uy; 0x86uy; 0x35uy; 0x5euy; 0x3euy; 0x88uy; 0x69uy; 0x99uy; 0x4buy; 0xeeuy; 0xbeuy; 0x9auy; 0x99uy; 0xb5uy; 0x6euy; 0x58uy; 0xaeuy; 0xdduy; 0x22uy; 0xdbuy; 0xdduy; 0x6buy; 0xfcuy; 0xafuy; 0x90uy; 0xa3uy; 0x3duy; 0xa4uy; 0xc1uy; 0x15uy; 0x92uy; 0x18uy; 0x8duy; 0xd2uy; 0x4buy; 0x7buy; 0x06uy; 0xd1uy; 0x37uy; 0xb5uy; 0xe2uy; 0x7cuy; 0x2cuy; 0xf0uy; 0x25uy; 0xe4uy; 0x94uy; 0x2auy; 0xbduy; 0xe3uy; 0x82uy; 0x70uy; 0x78uy; 0xa3uy; 0x82uy; 0x10uy; 0x5auy; 0x90uy; 0xd7uy; 0xa4uy; 0xfauy; 0xafuy; 0x1auy; 0x88uy; 0x59uy; 0xdcuy; 0x74uy; 0x12uy; 0xb4uy; 0x8euy; 0xd7uy; 0x19uy; 0x46uy; 0xf4uy; 0x84uy; 0x69uy; 0x9fuy; 0xbbuy; 0x70uy; 0xa8uy; 0x4cuy; 0x52uy; 0x81uy; 0xa9uy; 0xffuy; 0x76uy; 0x1cuy; 0xaeuy; 0xd8uy; 0x11uy; 0x3duy; 0x7fuy; 0x7duy; 0xc5uy; 0x12uy; 0x59uy; 0x28uy; 0x18uy; 0xc2uy; 0xa2uy; 0xb7uy; 0x1cuy; 0x88uy; 0xf8uy; 0xd6uy; 0x1buy; 0xa6uy; 0x7duy; 0x9euy; 0xdeuy; 0x29uy; 0xf8uy; 0xeduy; 0xffuy; 0xebuy; 0x92uy; 0x24uy; 0x4fuy; 0x05uy; 0xaauy; 0xd9uy; 0x49uy; 0xbauy; 0x87uy; 0x59uy; 0x51uy; 0xc9uy; 0x20uy; 0x5cuy; 0x9buy; 0x74uy; 0xcfuy; 0x03uy; 0xd9uy; 0x2duy; 0x34uy; 0xc7uy; 0x5buy; 0xa5uy; 0x40uy; 0xb2uy; 0x99uy; 0xf5uy; 0xcbuy; 0xb4uy; 0xf6uy; 0xb7uy; 0x72uy; 0x4auy; 0xd6uy; 0xbduy; 0xb0uy; 0xf3uy; 0x93uy; 0xe0uy; 0x1buy; 0xa8uy; 0x04uy; 0x1euy; 0x35uy; 0xd4uy; 0x80uy; 0x20uy; 0xf4uy; 0x9cuy; 0x31uy; 0x6buy; 0x45uy; 0xb9uy; 0x15uy; 0xb0uy; 0x5euy; 0xdduy; 0x0auy; 0x33uy; 0x9cuy; 0x83uy; 0xcduy; 0x58uy; 0x89uy; 0x50uy; 0x56uy; 0xbbuy; 0x81uy; 0x00uy; 0x91uy; 0x32uy; 0xf3uy; 0x1buy; 0x3euy; 0xcfuy; 0x45uy; 0xe1uy; 0xf9uy; 0xe1uy; 0x2cuy; 0x26uy; 0x78uy; 0x93uy; 0x9auy; 0x60uy; 0x46uy; 0xc9uy; 0xb5uy; 0x5euy; 0x6auy; 0x28uy; 0x92uy; 0x87uy; 0x3fuy; 0x63uy; 0x7buy; 0xdbuy; 0xf7uy; 0xd0uy; 0x13uy; 0x9duy; 0x32uy; 0x40uy; 0x5euy; 0xcfuy; 0xfbuy; 0x79uy; 0x68uy; 0x47uy; 0x4cuy; 0xfduy; 0x01uy; 0x17uy; 0xe6uy; 0x97uy; 0x93uy; 0x78uy; 0xbbuy; 0xa6uy; 0x27uy; 0xa3uy; 0xe8uy; 0x1auy; 0xe8uy; 0x94uy; 0x55uy; 0x7duy; 0x08uy; 0xe5uy; 0xdcuy; 0x66uy; 0xa3uy; 0x69uy; 0xc8uy; 0xcauy; 0xc5uy; 0xa1uy; 0x84uy; 0x55uy; 0xdeuy; 0x08uy; 0x91uy; 0x16uy; 0x3auy; 0x0cuy; 0x86uy; 0xabuy; 0x27uy; 0x2buy; 0x64uy; 0x34uy; 0x02uy; 0x6cuy; 0x76uy; 0x8buy; 0xc6uy; 0xafuy; 0xccuy; 0xe1uy; 0xd6uy; 0x8cuy; 0x2auy; 0x18uy; 0x3duy; 0xa6uy; 0x1buy; 0x37uy; 0x75uy; 0x45uy; 0x73uy; 0xc2uy; 0x75uy; 0xd7uy; 0x53uy; 0x78uy; 0x3auy; 0xd6uy; 0xe8uy; 0x29uy; 0xd2uy; 0x4auy; 0xa8uy; 0x1euy; 0x82uy; 0xf6uy; 0xb6uy; 0x81uy; 0xdeuy; 0x21uy; 0xeduy; 0x2buy; 0x56uy; 0xbbuy; 0xf2uy; 0xd0uy; 0x57uy; 0xc1uy; 0x7cuy; 0xd2uy; 0x6auy; 0xd2uy; 0x56uy; 0xf5uy; 0x13uy; 0x5fuy; 0x1cuy; 0x6auy; 0x0buy; 0x74uy; 0xfbuy; 0xe9uy; 0xfeuy; 0x9euy; 0xeauy; 0x95uy; 0xb2uy; 0x46uy; 0xabuy; 0x0auy; 0xfcuy; 0xfduy; 0xf3uy; 0xbbuy; 0x04uy; 0x2buy; 0x76uy; 0x1buy; 0xa4uy; 0x74uy; 0xb0uy; 0xc1uy; 0x78uy; 0xc3uy; 0x69uy; 0xe2uy; 0xb0uy; 0x01uy; 0xe1uy; 0xdeuy; 0x32uy; 0x4cuy; 0x8duy; 0x1auy; 0xb3uy; 0x38uy; 0x08uy; 0xd5uy; 0xfcuy; 0x1fuy; 0xdcuy; 0x0euy; 0x2cuy; 0x9cuy; 0xb1uy; 0xa1uy; 0x63uy; 0x17uy; 0x22uy; 0xf5uy; 0x6cuy; 0x93uy; 0x70uy; 0x74uy; 0x00uy; 0xf8uy; 0x39uy; 0x01uy; 0x94uy; 0xd1uy; 0x32uy; 0x23uy; 0x56uy; 0x5duy; 0xa6uy; 0x02uy; 0x76uy; 0x76uy; 0x93uy; 0xceuy; 0x2fuy; 0x19uy; 0xe9uy; 0x17uy; 0x52uy; 0xaeuy; 0x6euy; 0x2cuy; 0x6duy; 0x61uy; 0x7fuy; 0x3buy; 0xaauy; 0xe0uy; 0x52uy; 0x85uy; 0xc5uy; 0x65uy; 0xc1uy; 0xbbuy; 0x8euy; 0x5buy; 0x21uy; 0xd5uy; 0xc9uy; 0x78uy; 0x83uy; 0x07uy; 0x97uy; 0x4cuy; 0x62uy; 0x61uy; 0x41uy; 0xd4uy; 0xfcuy; 0xc9uy; 0x39uy; 0xe3uy; 0x9buy; 0xd0uy; 0xccuy; 0x75uy; 0xc4uy; 0x97uy; 0xe6uy; 0xdduy; 0x2auy; 0x5fuy; 0xa6uy; 0xe8uy; 0x59uy; 0x6cuy; 0x98uy; 0xb9uy; 0x02uy; 0xe2uy; 0xa2uy; 0xd6uy; 0x68uy; 0xeeuy; 0x3buy; 0x1duy; 0xe3uy; 0x4duy; 0x5buy; 0x30uy; 0xefuy; 0x03uy; 0xf2uy; 0xebuy; 0x18uy; 0x57uy; 0x36uy; 0xe8uy; 0xa1uy; 0xf4uy; 0x47uy; 0xfbuy; 0xcbuy; 0x8fuy; 0xcbuy; 0xc8uy; 0xf3uy; 0x4fuy; 0x74uy; 0x9duy; 0x9duy; 0xb1uy; 0x8duy; 0x14uy; 0x44uy; 0xd9uy; 0x19uy; 0xb4uy; 0x54uy; 0x4fuy; 0x75uy; 0x19uy; 0x09uy; 0xa0uy; 0x75uy; 0xbcuy; 0x3buy; 0x82uy; 0xc6uy; 0x3fuy; 0xb8uy; 0x83uy; 0x19uy; 0x6euy; 0xd6uy; 0x37uy; 0xfeuy; 0x6euy; 0x8auy; 0x4euy; 0xe0uy; 0x4auy; 0xabuy; 0x7buy; 0xc8uy; 0xb4uy; 0x1duy; 0xf4uy; 0xeduy; 0x27uy; 0x03uy; 0x65uy; 0xa2uy; 0xa1uy; 0xaeuy; 0x11uy; 0xe7uy; 0x98uy; 0x78uy; 0x48uy; 0x91uy; 0xd2uy; 0xd2uy; 0xd4uy; 0x23uy; 0x78uy; 0x50uy; 0xb1uy; 0x5buy; 0x85uy; 0x10uy; 0x8duy; 0xcauy; 0x5fuy; 0x0fuy; 0x71uy; 0xaeuy; 0x72uy; 0x9auy; 0xf6uy; 0x25uy; 0x19uy; 0x60uy; 0x06uy; 0xf7uy; 0x10uy; 0x34uy; 0x18uy; 0x0duy; 0xc9uy; 0x9fuy; 0x7buy; 0x0cuy; 0x9buy; 0x8fuy; 0x91uy; 0x1buy; 0x9fuy; 0xcduy; 0x10uy; 0xeeuy; 0x75uy; 0xf9uy; 0x97uy; 0x66uy; 0xfcuy; 0x4duy; 0x33uy; 0x6euy; 0x28uy; 0x2buy; 0x92uy; 0x85uy; 0x4fuy; 0xabuy; 0x43uy; 0x8duy; 0x8fuy; 0x7duy; 0x86uy; 0xa7uy; 0xc7uy; 0xd8uy; 0xd3uy; 0x0buy; 0x8buy; 0x57uy; 0xb6uy; 0x1duy; 0x95uy; 0x0duy; 0xe9uy; 0xbcuy; 0xd9uy; 0x03uy; 0xd9uy; 0x10uy; 0x19uy; 0xc3uy; 0x46uy; 0x63uy; 0x55uy; 0x87uy; 0x61uy; 0x79uy; 0x6cuy; 0x95uy; 0x0euy; 0x9cuy; 0xdduy; 0xcauy; 0xc3uy; 0xf3uy; 0x64uy; 0xf0uy; 0x7duy; 0x76uy; 0xb7uy; 0x53uy; 0x67uy; 0x2buy; 0x1euy; 0x44uy; 0x56uy; 0x81uy; 0xeauy; 0x8fuy; 0x5cuy; 0x42uy; 0x16uy; 0xb8uy; 0x28uy; 0xebuy; 0x1buy; 0x61uy; 0x10uy; 0x1euy; 0xbfuy; 0xecuy; 0xa8uy; ] in
assert_norm (List.Tot.length l = 1933);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input10_len: (x:UInt32.t { UInt32.v x = B.length input10 }) =
1933ul
let output10: (b: B.buffer UInt8.t { B.length b = 1949 /\ B.recallable b }) =
[@inline_let] let l = [ 0x6auy; 0xfcuy; 0x4buy; 0x25uy; 0xdfuy; 0xc0uy; 0xe4uy; 0xe8uy; 0x17uy; 0x4duy; 0x4cuy; 0xc9uy; 0x7euy; 0xdeuy; 0x3auy; 0xccuy; 0x3cuy; 0xbauy; 0x6auy; 0x77uy; 0x47uy; 0xdbuy; 0xe3uy; 0x74uy; 0x7auy; 0x4duy; 0x5fuy; 0x8duy; 0x37uy; 0x55uy; 0x80uy; 0x73uy; 0x90uy; 0x66uy; 0x5duy; 0x3auy; 0x7duy; 0x5duy; 0x86uy; 0x5euy; 0x8duy; 0xfduy; 0x83uy; 0xffuy; 0x4euy; 0x74uy; 0x6fuy; 0xf9uy; 0xe6uy; 0x70uy; 0x17uy; 0x70uy; 0x3euy; 0x96uy; 0xa7uy; 0x7euy; 0xcbuy; 0xabuy; 0x8fuy; 0x58uy; 0x24uy; 0x9buy; 0x01uy; 0xfduy; 0xcbuy; 0xe6uy; 0x4duy; 0x9buy; 0xf0uy; 0x88uy; 0x94uy; 0x57uy; 0x66uy; 0xefuy; 0x72uy; 0x4cuy; 0x42uy; 0x6euy; 0x16uy; 0x19uy; 0x15uy; 0xeauy; 0x70uy; 0x5buy; 0xacuy; 0x13uy; 0xdbuy; 0x9fuy; 0x18uy; 0xe2uy; 0x3cuy; 0x26uy; 0x97uy; 0xbcuy; 0xdcuy; 0x45uy; 0x8cuy; 0x6cuy; 0x24uy; 0x69uy; 0x9cuy; 0xf7uy; 0x65uy; 0x1euy; 0x18uy; 0x59uy; 0x31uy; 0x7cuy; 0xe4uy; 0x73uy; 0xbcuy; 0x39uy; 0x62uy; 0xc6uy; 0x5cuy; 0x9fuy; 0xbfuy; 0xfauy; 0x90uy; 0x03uy; 0xc9uy; 0x72uy; 0x26uy; 0xb6uy; 0x1buy; 0xc2uy; 0xb7uy; 0x3fuy; 0xf2uy; 0x13uy; 0x77uy; 0xf2uy; 0x8duy; 0xb9uy; 0x47uy; 0xd0uy; 0x53uy; 0xdduy; 0xc8uy; 0x91uy; 0x83uy; 0x8buy; 0xb1uy; 0xceuy; 0xa3uy; 0xfeuy; 0xcduy; 0xd9uy; 0xdduy; 0x92uy; 0x7buy; 0xdbuy; 0xb8uy; 0xfbuy; 0xc9uy; 0x2duy; 0x01uy; 0x59uy; 0x39uy; 0x52uy; 0xaduy; 0x1buy; 0xecuy; 0xcfuy; 0xd7uy; 0x70uy; 0x13uy; 0x21uy; 0xf5uy; 0x47uy; 0xaauy; 0x18uy; 0x21uy; 0x5cuy; 0xc9uy; 0x9auy; 0xd2uy; 0x6buy; 0x05uy; 0x9cuy; 0x01uy; 0xa1uy; 0xdauy; 0x35uy; 0x5duy; 0xb3uy; 0x70uy; 0xe6uy; 0xa9uy; 0x80uy; 0x8buy; 0x91uy; 0xb7uy; 0xb3uy; 0x5fuy; 0x24uy; 0x9auy; 0xb7uy; 0xd1uy; 0x6buy; 0xa1uy; 0x1cuy; 0x50uy; 0xbauy; 0x49uy; 0xe0uy; 0xeeuy; 0x2euy; 0x75uy; 0xacuy; 0x69uy; 0xc0uy; 0xebuy; 0x03uy; 0xdduy; 0x19uy; 0xe5uy; 0xf6uy; 0x06uy; 0xdduy; 0xc3uy; 0xd7uy; 0x2buy; 0x07uy; 0x07uy; 0x30uy; 0xa7uy; 0x19uy; 0x0cuy; 0xbfuy; 0xe6uy; 0x18uy; 0xccuy; 0xb1uy; 0x01uy; 0x11uy; 0x85uy; 0x77uy; 0x1duy; 0x96uy; 0xa7uy; 0xa3uy; 0x00uy; 0x84uy; 0x02uy; 0xa2uy; 0x83uy; 0x68uy; 0xdauy; 0x17uy; 0x27uy; 0xc8uy; 0x7fuy; 0x23uy; 0xb7uy; 0xf4uy; 0x13uy; 0x85uy; 0xcfuy; 0xdduy; 0x7auy; 0x7duy; 0x24uy; 0x57uy; 0xfeuy; 0x05uy; 0x93uy; 0xf5uy; 0x74uy; 0xceuy; 0xeduy; 0x0cuy; 0x20uy; 0x98uy; 0x8duy; 0x92uy; 0x30uy; 0xa1uy; 0x29uy; 0x23uy; 0x1auy; 0xa0uy; 0x4fuy; 0x69uy; 0x56uy; 0x4cuy; 0xe1uy; 0xc8uy; 0xceuy; 0xf6uy; 0x9auy; 0x0cuy; 0xa4uy; 0xfauy; 0x04uy; 0xf6uy; 0x62uy; 0x95uy; 0xf2uy; 0xfauy; 0xc7uy; 0x40uy; 0x68uy; 0x40uy; 0x8fuy; 0x41uy; 0xdauy; 0xb4uy; 0x26uy; 0x6fuy; 0x70uy; 0xabuy; 0x40uy; 0x61uy; 0xa4uy; 0x0euy; 0x75uy; 0xfbuy; 0x86uy; 0xebuy; 0x9duy; 0x9auy; 0x1fuy; 0xecuy; 0x76uy; 0x99uy; 0xe7uy; 0xeauy; 0xaauy; 0x1euy; 0x2duy; 0xb5uy; 0xd4uy; 0xa6uy; 0x1auy; 0xb8uy; 0x61uy; 0x0auy; 0x1duy; 0x16uy; 0x5buy; 0x98uy; 0xc2uy; 0x31uy; 0x40uy; 0xe7uy; 0x23uy; 0x1duy; 0x66uy; 0x99uy; 0xc8uy; 0xc0uy; 0xd7uy; 0xceuy; 0xf3uy; 0x57uy; 0x40uy; 0x04uy; 0x3fuy; 0xfcuy; 0xeauy; 0xb3uy; 0xfcuy; 0xd2uy; 0xd3uy; 0x99uy; 0xa4uy; 0x94uy; 0x69uy; 0xa0uy; 0xefuy; 0xd1uy; 0x85uy; 0xb3uy; 0xa6uy; 0xb1uy; 0x28uy; 0xbfuy; 0x94uy; 0x67uy; 0x22uy; 0xc3uy; 0x36uy; 0x46uy; 0xf8uy; 0xd2uy; 0x0fuy; 0x5fuy; 0xf4uy; 0x59uy; 0x80uy; 0xe6uy; 0x2duy; 0x43uy; 0x08uy; 0x7duy; 0x19uy; 0x09uy; 0x97uy; 0xa7uy; 0x4cuy; 0x3duy; 0x8duy; 0xbauy; 0x65uy; 0x62uy; 0xa3uy; 0x71uy; 0x33uy; 0x29uy; 0x62uy; 0xdbuy; 0xc1uy; 0x33uy; 0x34uy; 0x1auy; 0x63uy; 0x33uy; 0x16uy; 0xb6uy; 0x64uy; 0x7euy; 0xabuy; 0x33uy; 0xf0uy; 0xe6uy; 0x26uy; 0x68uy; 0xbauy; 0x1duy; 0x2euy; 0x38uy; 0x08uy; 0xe6uy; 0x02uy; 0xd3uy; 0x25uy; 0x2cuy; 0x47uy; 0x23uy; 0x58uy; 0x34uy; 0x0fuy; 0x9duy; 0x63uy; 0x4fuy; 0x63uy; 0xbbuy; 0x7fuy; 0x3buy; 0x34uy; 0x38uy; 0xa7uy; 0xb5uy; 0x8duy; 0x65uy; 0xd9uy; 0x9fuy; 0x79uy; 0x55uy; 0x3euy; 0x4duy; 0xe7uy; 0x73uy; 0xd8uy; 0xf6uy; 0x98uy; 0x97uy; 0x84uy; 0x60uy; 0x9cuy; 0xc8uy; 0xa9uy; 0x3cuy; 0xf6uy; 0xdcuy; 0x12uy; 0x5cuy; 0xe1uy; 0xbbuy; 0x0buy; 0x8buy; 0x98uy; 0x9cuy; 0x9duy; 0x26uy; 0x7cuy; 0x4auy; 0xe6uy; 0x46uy; 0x36uy; 0x58uy; 0x21uy; 0x4auy; 0xeeuy; 0xcauy; 0xd7uy; 0x3buy; 0xc2uy; 0x6cuy; 0x49uy; 0x2fuy; 0xe5uy; 0xd5uy; 0x03uy; 0x59uy; 0x84uy; 0x53uy; 0xcbuy; 0xfeuy; 0x92uy; 0x71uy; 0x2euy; 0x7cuy; 0x21uy; 0xccuy; 0x99uy; 0x85uy; 0x7fuy; 0xb8uy; 0x74uy; 0x90uy; 0x13uy; 0x42uy; 0x3fuy; 0xe0uy; 0x6buy; 0x1duy; 0xf2uy; 0x4duy; 0x54uy; 0xd4uy; 0xfcuy; 0x3auy; 0x05uy; 0xe6uy; 0x74uy; 0xafuy; 0xa6uy; 0xa0uy; 0x2auy; 0x20uy; 0x23uy; 0x5duy; 0x34uy; 0x5cuy; 0xd9uy; 0x3euy; 0x4euy; 0xfauy; 0x93uy; 0xe7uy; 0xaauy; 0xe9uy; 0x6fuy; 0x08uy; 0x43uy; 0x67uy; 0x41uy; 0xc5uy; 0xaduy; 0xfbuy; 0x31uy; 0x95uy; 0x82uy; 0x73uy; 0x32uy; 0xd8uy; 0xa6uy; 0xa3uy; 0xeduy; 0x0euy; 0x2duy; 0xf6uy; 0x5fuy; 0xfduy; 0x80uy; 0xa6uy; 0x7auy; 0xe0uy; 0xdfuy; 0x78uy; 0x15uy; 0x29uy; 0x74uy; 0x33uy; 0xd0uy; 0x9euy; 0x83uy; 0x86uy; 0x72uy; 0x22uy; 0x57uy; 0x29uy; 0xb9uy; 0x9euy; 0x5duy; 0xd3uy; 0x1auy; 0xb5uy; 0x96uy; 0x72uy; 0x41uy; 0x3duy; 0xf1uy; 0x64uy; 0x43uy; 0x67uy; 0xeeuy; 0xaauy; 0x5cuy; 0xd3uy; 0x9auy; 0x96uy; 0x13uy; 0x11uy; 0x5duy; 0xf3uy; 0x0cuy; 0x87uy; 0x82uy; 0x1euy; 0x41uy; 0x9euy; 0xd0uy; 0x27uy; 0xd7uy; 0x54uy; 0x3buy; 0x67uy; 0x73uy; 0x09uy; 0x91uy; 0xe9uy; 0xd5uy; 0x36uy; 0xa7uy; 0xb5uy; 0x55uy; 0xe4uy; 0xf3uy; 0x21uy; 0x51uy; 0x49uy; 0x22uy; 0x07uy; 0x55uy; 0x4fuy; 0x44uy; 0x4buy; 0xd2uy; 0x15uy; 0x93uy; 0x17uy; 0x2auy; 0xfauy; 0x4duy; 0x4auy; 0x57uy; 0xdbuy; 0x4cuy; 0xa6uy; 0xebuy; 0xecuy; 0x53uy; 0x25uy; 0x6cuy; 0x21uy; 0xeduy; 0x00uy; 0x4cuy; 0x3buy; 0xcauy; 0x14uy; 0x57uy; 0xa9uy; 0xd6uy; 0x6auy; 0xcduy; 0x8duy; 0x5euy; 0x74uy; 0xacuy; 0x72uy; 0xc1uy; 0x97uy; 0xe5uy; 0x1buy; 0x45uy; 0x4euy; 0xdauy; 0xfcuy; 0xccuy; 0x40uy; 0xe8uy; 0x48uy; 0x88uy; 0x0buy; 0xa3uy; 0xe3uy; 0x8duy; 0x83uy; 0x42uy; 0xc3uy; 0x23uy; 0xfduy; 0x68uy; 0xb5uy; 0x8euy; 0xf1uy; 0x9duy; 0x63uy; 0x77uy; 0xe9uy; 0xa3uy; 0x8euy; 0x8cuy; 0x26uy; 0x6buy; 0xbduy; 0x72uy; 0x73uy; 0x35uy; 0x0cuy; 0x03uy; 0xf8uy; 0x43uy; 0x78uy; 0x52uy; 0x71uy; 0x15uy; 0x1fuy; 0x71uy; 0x5duy; 0x6euy; 0xeduy; 0xb9uy; 0xccuy; 0x86uy; 0x30uy; 0xdbuy; 0x2buy; 0xd3uy; 0x82uy; 0x88uy; 0x23uy; 0x71uy; 0x90uy; 0x53uy; 0x5cuy; 0xa9uy; 0x2fuy; 0x76uy; 0x01uy; 0xb7uy; 0x9auy; 0xfeuy; 0x43uy; 0x55uy; 0xa3uy; 0x04uy; 0x9buy; 0x0euy; 0xe4uy; 0x59uy; 0xdfuy; 0xc9uy; 0xe9uy; 0xb1uy; 0xeauy; 0x29uy; 0x28uy; 0x3cuy; 0x5cuy; 0xaeuy; 0x72uy; 0x84uy; 0xb6uy; 0xc6uy; 0xebuy; 0x0cuy; 0x27uy; 0x07uy; 0x74uy; 0x90uy; 0x0duy; 0x31uy; 0xb0uy; 0x00uy; 0x77uy; 0xe9uy; 0x40uy; 0x70uy; 0x6fuy; 0x68uy; 0xa7uy; 0xfduy; 0x06uy; 0xecuy; 0x4buy; 0xc0uy; 0xb7uy; 0xacuy; 0xbcuy; 0x33uy; 0xb7uy; 0x6duy; 0x0auy; 0xbduy; 0x12uy; 0x1buy; 0x59uy; 0xcbuy; 0xdduy; 0x32uy; 0xf5uy; 0x1duy; 0x94uy; 0x57uy; 0x76uy; 0x9euy; 0x0cuy; 0x18uy; 0x98uy; 0x71uy; 0xd7uy; 0x2auy; 0xdbuy; 0x0buy; 0x7buy; 0xa7uy; 0x71uy; 0xb7uy; 0x67uy; 0x81uy; 0x23uy; 0x96uy; 0xaeuy; 0xb9uy; 0x7euy; 0x32uy; 0x43uy; 0x92uy; 0x8auy; 0x19uy; 0xa0uy; 0xc4uy; 0xd4uy; 0x3buy; 0x57uy; 0xf9uy; 0x4auy; 0x2cuy; 0xfbuy; 0x51uy; 0x46uy; 0xbbuy; 0xcbuy; 0x5duy; 0xb3uy; 0xefuy; 0x13uy; 0x93uy; 0x6euy; 0x68uy; 0x42uy; 0x54uy; 0x57uy; 0xd3uy; 0x6auy; 0x3auy; 0x8fuy; 0x9duy; 0x66uy; 0xbfuy; 0xbduy; 0x36uy; 0x23uy; 0xf5uy; 0x93uy; 0x83uy; 0x7buy; 0x9cuy; 0xc0uy; 0xdduy; 0xc5uy; 0x49uy; 0xc0uy; 0x64uy; 0xeduy; 0x07uy; 0x12uy; 0xb3uy; 0xe6uy; 0xe4uy; 0xe5uy; 0x38uy; 0x95uy; 0x23uy; 0xb1uy; 0xa0uy; 0x3buy; 0x1auy; 0x61uy; 0xdauy; 0x17uy; 0xacuy; 0xc3uy; 0x58uy; 0xdduy; 0x74uy; 0x64uy; 0x22uy; 0x11uy; 0xe8uy; 0x32uy; 0x1duy; 0x16uy; 0x93uy; 0x85uy; 0x99uy; 0xa5uy; 0x9cuy; 0x34uy; 0x55uy; 0xb1uy; 0xe9uy; 0x20uy; 0x72uy; 0xc9uy; 0x28uy; 0x7buy; 0x79uy; 0x00uy; 0xa1uy; 0xa6uy; 0xa3uy; 0x27uy; 0x40uy; 0x18uy; 0x8auy; 0x54uy; 0xe0uy; 0xccuy; 0xe8uy; 0x4euy; 0x8euy; 0x43uy; 0x96uy; 0xe7uy; 0x3fuy; 0xc8uy; 0xe9uy; 0xb2uy; 0xf9uy; 0xc9uy; 0xdauy; 0x04uy; 0x71uy; 0x50uy; 0x47uy; 0xe4uy; 0xaauy; 0xceuy; 0xa2uy; 0x30uy; 0xc8uy; 0xe4uy; 0xacuy; 0xc7uy; 0x0duy; 0x06uy; 0x2euy; 0xe6uy; 0xe8uy; 0x80uy; 0x36uy; 0x29uy; 0x9euy; 0x01uy; 0xb8uy; 0xc3uy; 0xf0uy; 0xa0uy; 0x5duy; 0x7auy; 0xcauy; 0x4duy; 0xa0uy; 0x57uy; 0xbduy; 0x2auy; 0x45uy; 0xa7uy; 0x7fuy; 0x9cuy; 0x93uy; 0x07uy; 0x8fuy; 0x35uy; 0x67uy; 0x92uy; 0xe3uy; 0xe9uy; 0x7fuy; 0xa8uy; 0x61uy; 0x43uy; 0x9euy; 0x25uy; 0x4fuy; 0x33uy; 0x76uy; 0x13uy; 0x6euy; 0x12uy; 0xb9uy; 0xdduy; 0xa4uy; 0x7cuy; 0x08uy; 0x9fuy; 0x7cuy; 0xe7uy; 0x0auy; 0x8duy; 0x84uy; 0x06uy; 0xa4uy; 0x33uy; 0x17uy; 0x34uy; 0x5euy; 0x10uy; 0x7cuy; 0xc0uy; 0xa8uy; 0x3duy; 0x1fuy; 0x42uy; 0x20uy; 0x51uy; 0x65uy; 0x5duy; 0x09uy; 0xc3uy; 0xaauy; 0xc0uy; 0xc8uy; 0x0duy; 0xf0uy; 0x79uy; 0xbcuy; 0x20uy; 0x1buy; 0x95uy; 0xe7uy; 0x06uy; 0x7duy; 0x47uy; 0x20uy; 0x03uy; 0x1auy; 0x74uy; 0xdduy; 0xe2uy; 0xd4uy; 0xaeuy; 0x38uy; 0x71uy; 0x9buy; 0xf5uy; 0x80uy; 0xecuy; 0x08uy; 0x4euy; 0x56uy; 0xbauy; 0x76uy; 0x12uy; 0x1auy; 0xdfuy; 0x48uy; 0xf3uy; 0xaeuy; 0xb3uy; 0xe6uy; 0xe6uy; 0xbeuy; 0xc0uy; 0x91uy; 0x2euy; 0x01uy; 0xb3uy; 0x01uy; 0x86uy; 0xa2uy; 0xb9uy; 0x52uy; 0xd1uy; 0x21uy; 0xaeuy; 0xd4uy; 0x97uy; 0x1duy; 0xefuy; 0x41uy; 0x12uy; 0x95uy; 0x3duy; 0x48uy; 0x45uy; 0x1cuy; 0x56uy; 0x32uy; 0x8fuy; 0xb8uy; 0x43uy; 0xbbuy; 0x19uy; 0xf3uy; 0xcauy; 0xe9uy; 0xebuy; 0x6duy; 0x84uy; 0xbeuy; 0x86uy; 0x06uy; 0xe2uy; 0x36uy; 0xb2uy; 0x62uy; 0x9duy; 0xd3uy; 0x4cuy; 0x48uy; 0x18uy; 0x54uy; 0x13uy; 0x4euy; 0xcfuy; 0xfduy; 0xbauy; 0x84uy; 0xb9uy; 0x30uy; 0x53uy; 0xcfuy; 0xfbuy; 0xb9uy; 0x29uy; 0x8fuy; 0xdcuy; 0x9fuy; 0xefuy; 0x60uy; 0x0buy; 0x64uy; 0xf6uy; 0x8buy; 0xeeuy; 0xa6uy; 0x91uy; 0xc2uy; 0x41uy; 0x6cuy; 0xf6uy; 0xfauy; 0x79uy; 0x67uy; 0x4buy; 0xc1uy; 0x3fuy; 0xafuy; 0x09uy; 0x81uy; 0xd4uy; 0x5duy; 0xcbuy; 0x09uy; 0xdfuy; 0x36uy; 0x31uy; 0xc0uy; 0x14uy; 0x3cuy; 0x7cuy; 0x0euy; 0x65uy; 0x95uy; 0x99uy; 0x6duy; 0xa3uy; 0xf4uy; 0xd7uy; 0x38uy; 0xeeuy; 0x1auy; 0x2buy; 0x37uy; 0xe2uy; 0xa4uy; 0x3buy; 0x4buy; 0xd0uy; 0x65uy; 0xcauy; 0xf8uy; 0xc3uy; 0xe8uy; 0x15uy; 0x20uy; 0xefuy; 0xf2uy; 0x00uy; 0xfduy; 0x01uy; 0x09uy; 0xc5uy; 0xc8uy; 0x17uy; 0x04uy; 0x93uy; 0xd0uy; 0x93uy; 0x03uy; 0x55uy; 0xc5uy; 0xfeuy; 0x32uy; 0xa3uy; 0x3euy; 0x28uy; 0x2duy; 0x3buy; 0x93uy; 0x8auy; 0xccuy; 0x07uy; 0x72uy; 0x80uy; 0x8buy; 0x74uy; 0x16uy; 0x24uy; 0xbbuy; 0xdauy; 0x94uy; 0x39uy; 0x30uy; 0x8fuy; 0xb1uy; 0xcduy; 0x4auy; 0x90uy; 0x92uy; 0x7cuy; 0x14uy; 0x8fuy; 0x95uy; 0x4euy; 0xacuy; 0x9buy; 0xd8uy; 0x8fuy; 0x1auy; 0x87uy; 0xa4uy; 0x32uy; 0x27uy; 0x8auy; 0xbauy; 0xf7uy; 0x41uy; 0xcfuy; 0x84uy; 0x37uy; 0x19uy; 0xe6uy; 0x06uy; 0xf5uy; 0x0euy; 0xcfuy; 0x36uy; 0xf5uy; 0x9euy; 0x6cuy; 0xdeuy; 0xbcuy; 0xffuy; 0x64uy; 0x7euy; 0x4euy; 0x59uy; 0x57uy; 0x48uy; 0xfeuy; 0x14uy; 0xf7uy; 0x9cuy; 0x93uy; 0x5duy; 0x15uy; 0xaduy; 0xccuy; 0x11uy; 0xb1uy; 0x17uy; 0x18uy; 0xb2uy; 0x7euy; 0xccuy; 0xabuy; 0xe9uy; 0xceuy; 0x7duy; 0x77uy; 0x5buy; 0x51uy; 0x1buy; 0x1euy; 0x20uy; 0xa8uy; 0x32uy; 0x06uy; 0x0euy; 0x75uy; 0x93uy; 0xacuy; 0xdbuy; 0x35uy; 0x37uy; 0x1fuy; 0xe9uy; 0x19uy; 0x1duy; 0xb4uy; 0x71uy; 0x97uy; 0xd6uy; 0x4euy; 0x2cuy; 0x08uy; 0xa5uy; 0x13uy; 0xf9uy; 0x0euy; 0x7euy; 0x78uy; 0x6euy; 0x14uy; 0xe0uy; 0xa9uy; 0xb9uy; 0x96uy; 0x4cuy; 0x80uy; 0x82uy; 0xbauy; 0x17uy; 0xb3uy; 0x9duy; 0x69uy; 0xb0uy; 0x84uy; 0x46uy; 0xffuy; 0xf9uy; 0x52uy; 0x79uy; 0x94uy; 0x58uy; 0x3auy; 0x62uy; 0x90uy; 0x15uy; 0x35uy; 0x71uy; 0x10uy; 0x37uy; 0xeduy; 0xa1uy; 0x8euy; 0x53uy; 0x6euy; 0xf4uy; 0x26uy; 0x57uy; 0x93uy; 0x15uy; 0x93uy; 0xf6uy; 0x81uy; 0x2cuy; 0x5auy; 0x10uy; 0xdauy; 0x92uy; 0xaduy; 0x2fuy; 0xdbuy; 0x28uy; 0x31uy; 0x2duy; 0x55uy; 0x04uy; 0xd2uy; 0x06uy; 0x28uy; 0x8cuy; 0x1euy; 0xdcuy; 0xeauy; 0x54uy; 0xacuy; 0xffuy; 0xb7uy; 0x6cuy; 0x30uy; 0x15uy; 0xd4uy; 0xb4uy; 0x0duy; 0x00uy; 0x93uy; 0x57uy; 0xdduy; 0xd2uy; 0x07uy; 0x07uy; 0x06uy; 0xd9uy; 0x43uy; 0x9buy; 0xcduy; 0x3auy; 0xf4uy; 0x7duy; 0x4cuy; 0x36uy; 0x5duy; 0x23uy; 0xa2uy; 0xccuy; 0x57uy; 0x40uy; 0x91uy; 0xe9uy; 0x2cuy; 0x2fuy; 0x2cuy; 0xd5uy; 0x30uy; 0x9buy; 0x17uy; 0xb0uy; 0xc9uy; 0xf7uy; 0xa7uy; 0x2fuy; 0xd1uy; 0x93uy; 0x20uy; 0x6buy; 0xc6uy; 0xc1uy; 0xe4uy; 0x6fuy; 0xcbuy; 0xd1uy; 0xe7uy; 0x09uy; 0x0fuy; 0x9euy; 0xdcuy; 0xaauy; 0x9fuy; 0x2fuy; 0xdfuy; 0x56uy; 0x9fuy; 0xd4uy; 0x33uy; 0x04uy; 0xafuy; 0xd3uy; 0x6cuy; 0x58uy; 0x61uy; 0xf0uy; 0x30uy; 0xecuy; 0xf2uy; 0x7fuy; 0xf2uy; 0x9cuy; 0xdfuy; 0x39uy; 0xbbuy; 0x6fuy; 0xa2uy; 0x8cuy; 0x7euy; 0xc4uy; 0x22uy; 0x51uy; 0x71uy; 0xc0uy; 0x4duy; 0x14uy; 0x1auy; 0xc4uy; 0xcduy; 0x04uy; 0xd9uy; 0x87uy; 0x08uy; 0x50uy; 0x05uy; 0xccuy; 0xafuy; 0xf6uy; 0xf0uy; 0x8fuy; 0x92uy; 0x54uy; 0x58uy; 0xc2uy; 0xc7uy; 0x09uy; 0x7auy; 0x59uy; 0x02uy; 0x05uy; 0xe8uy; 0xb0uy; 0x86uy; 0xd9uy; 0xbfuy; 0x7buy; 0x35uy; 0x51uy; 0x4duy; 0xafuy; 0x08uy; 0x97uy; 0x2cuy; 0x65uy; 0xdauy; 0x2auy; 0x71uy; 0x3auy; 0xa8uy; 0x51uy; 0xccuy; 0xf2uy; 0x73uy; 0x27uy; 0xc3uy; 0xfduy; 0x62uy; 0xcfuy; 0xe3uy; 0xb2uy; 0xcauy; 0xcbuy; 0xbeuy; 0x1auy; 0x0auy; 0xa1uy; 0x34uy; 0x7buy; 0x77uy; 0xc4uy; 0x62uy; 0x68uy; 0x78uy; 0x5fuy; 0x94uy; 0x07uy; 0x04uy; 0x65uy; 0x16uy; 0x4buy; 0x61uy; 0xcbuy; 0xffuy; 0x75uy; 0x26uy; 0x50uy; 0x66uy; 0x1fuy; 0x6euy; 0x93uy; 0xf8uy; 0xc5uy; 0x51uy; 0xebuy; 0xa4uy; 0x4auy; 0x48uy; 0x68uy; 0x6buy; 0xe2uy; 0x5euy; 0x44uy; 0xb2uy; 0x50uy; 0x2cuy; 0x6cuy; 0xaeuy; 0x79uy; 0x4euy; 0x66uy; 0x35uy; 0x81uy; 0x50uy; 0xacuy; 0xbcuy; 0x3fuy; 0xb1uy; 0x0cuy; 0xf3uy; 0x05uy; 0x3cuy; 0x4auy; 0xa3uy; 0x6cuy; 0x2auy; 0x79uy; 0xb4uy; 0xb7uy; 0xabuy; 0xcauy; 0xc7uy; 0x9buy; 0x8euy; 0xcduy; 0x5fuy; 0x11uy; 0x03uy; 0xcbuy; 0x30uy; 0xa3uy; 0xabuy; 0xdauy; 0xfeuy; 0x64uy; 0xb9uy; 0xbbuy; 0xd8uy; 0x5euy; 0x3auy; 0x1auy; 0x56uy; 0xe5uy; 0x05uy; 0x48uy; 0x90uy; 0x1euy; 0x61uy; 0x69uy; 0x1buy; 0x22uy; 0xe6uy; 0x1auy; 0x3cuy; 0x75uy; 0xaduy; 0x1fuy; 0x37uy; 0x28uy; 0xdcuy; 0xe4uy; 0x6duy; 0xbduy; 0x42uy; 0xdcuy; 0xd3uy; 0xc8uy; 0xb6uy; 0x1cuy; 0x48uy; 0xfeuy; 0x94uy; 0x77uy; 0x7fuy; 0xbduy; 0x62uy; 0xacuy; 0xa3uy; 0x47uy; 0x27uy; 0xcfuy; 0x5fuy; 0xd9uy; 0xdbuy; 0xafuy; 0xecuy; 0xf7uy; 0x5euy; 0xc1uy; 0xb0uy; 0x9duy; 0x01uy; 0x26uy; 0x99uy; 0x7euy; 0x8fuy; 0x03uy; 0x70uy; 0xb5uy; 0x42uy; 0xbeuy; 0x67uy; 0x28uy; 0x1buy; 0x7cuy; 0xbduy; 0x61uy; 0x21uy; 0x97uy; 0xccuy; 0x5cuy; 0xe1uy; 0x97uy; 0x8fuy; 0x8duy; 0xdeuy; 0x2buy; 0xaauy; 0xa7uy; 0x71uy; 0x1duy; 0x1euy; 0x02uy; 0x73uy; 0x70uy; 0x58uy; 0x32uy; 0x5buy; 0x1duy; 0x67uy; 0x3duy; 0xe0uy; 0x74uy; 0x4fuy; 0x03uy; 0xf2uy; 0x70uy; 0x51uy; 0x79uy; 0xf1uy; 0x61uy; 0x70uy; 0x15uy; 0x74uy; 0x9duy; 0x23uy; 0x89uy; 0xdeuy; 0xacuy; 0xfduy; 0xdeuy; 0xd0uy; 0x1fuy; 0xc3uy; 0x87uy; 0x44uy; 0x35uy; 0x4buy; 0xe5uy; 0xb0uy; 0x60uy; 0xc5uy; 0x22uy; 0xe4uy; 0x9euy; 0xcauy; 0xebuy; 0xd5uy; 0x3auy; 0x09uy; 0x45uy; 0xa4uy; 0xdbuy; 0xfauy; 0x3fuy; 0xebuy; 0x1buy; 0xc7uy; 0xc8uy; 0x14uy; 0x99uy; 0x51uy; 0x92uy; 0x10uy; 0xeduy; 0xeduy; 0x28uy; 0xe0uy; 0xa1uy; 0xf8uy; 0x26uy; 0xcfuy; 0xcduy; 0xcbuy; 0x63uy; 0xa1uy; 0x3buy; 0xe3uy; 0xdfuy; 0x7euy; 0xfeuy; 0xa6uy; 0xf0uy; 0x81uy; 0x9auy; 0xbfuy; 0x55uy; 0xdeuy; 0x54uy; 0xd5uy; 0x56uy; 0x60uy; 0x98uy; 0x10uy; 0x68uy; 0xf4uy; 0x38uy; 0x96uy; 0x8euy; 0x6fuy; 0x1duy; 0x44uy; 0x7fuy; 0xd6uy; 0x2fuy; 0xfeuy; 0x55uy; 0xfbuy; 0x0cuy; 0x7euy; 0x67uy; 0xe2uy; 0x61uy; 0x44uy; 0xeduy; 0xf2uy; 0x35uy; 0x30uy; 0x5duy; 0xe9uy; 0xc7uy; 0xd6uy; 0x6duy; 0xe0uy; 0xa0uy; 0xeduy; 0xf3uy; 0xfcuy; 0xd8uy; 0x3euy; 0x0auy; 0x7buy; 0xcduy; 0xafuy; 0x65uy; 0x68uy; 0x18uy; 0xc0uy; 0xecuy; 0x04uy; 0x1cuy; 0x74uy; 0x6duy; 0xe2uy; 0x6euy; 0x79uy; 0xd4uy; 0x11uy; 0x2buy; 0x62uy; 0xd5uy; 0x27uy; 0xaduy; 0x4fuy; 0x01uy; 0x59uy; 0x73uy; 0xccuy; 0x6auy; 0x53uy; 0xfbuy; 0x2duy; 0xd5uy; 0x4euy; 0x99uy; 0x21uy; 0x65uy; 0x4duy; 0xf5uy; 0x82uy; 0xf7uy; 0xd8uy; 0x42uy; 0xceuy; 0x6fuy; 0x3duy; 0x36uy; 0x47uy; 0xf1uy; 0x05uy; 0x16uy; 0xe8uy; 0x1buy; 0x6auy; 0x8fuy; 0x93uy; 0xf2uy; 0x8fuy; 0x37uy; 0x40uy; 0x12uy; 0x28uy; 0xa3uy; 0xe6uy; 0xb9uy; 0x17uy; 0x4auy; 0x1fuy; 0xb1uy; 0xd1uy; 0x66uy; 0x69uy; 0x86uy; 0xc4uy; 0xfcuy; 0x97uy; 0xaeuy; 0x3fuy; 0x8fuy; 0x1euy; 0x2buy; 0xdfuy; 0xcduy; 0xf9uy; 0x3cuy; ] in
assert_norm (List.Tot.length l = 1949);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output10_len: (x:UInt32.t { UInt32.v x = B.length output10 }) =
1949ul
let key11: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb3uy; 0x35uy; 0x50uy; 0x03uy; 0x54uy; 0x2euy; 0x40uy; 0x5euy; 0x8fuy; 0x59uy; 0x8euy; 0xc5uy; 0x90uy; 0xd5uy; 0x27uy; 0x2duy; 0xbauy; 0x29uy; 0x2euy; 0xcbuy; 0x1buy; 0x70uy; 0x44uy; 0x1euy; 0x65uy; 0x91uy; 0x6euy; 0x2auy; 0x79uy; 0x22uy; 0xdauy; 0x64uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key11_len: (x:UInt32.t { UInt32.v x = B.length key11 }) =
32ul
let nonce11: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x05uy; 0xa3uy; 0x93uy; 0xeduy; 0x30uy; 0xc5uy; 0xa2uy; 0x06uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce11_len: (x:UInt32.t { UInt32.v x = B.length nonce11 }) =
12ul
let aad11: (b: B.buffer UInt8.t { B.length b = 63 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb1uy; 0x69uy; 0x83uy; 0x87uy; 0x30uy; 0xaauy; 0x5duy; 0xb8uy; 0x77uy; 0xe8uy; 0x21uy; 0xffuy; 0x06uy; 0x59uy; 0x35uy; 0xceuy; 0x75uy; 0xfeuy; 0x38uy; 0xefuy; 0xb8uy; 0x91uy; 0x43uy; 0x8cuy; 0xcfuy; 0x70uy; 0xdduy; 0x0auy; 0x68uy; 0xbfuy; 0xd4uy; 0xbcuy; 0x16uy; 0x76uy; 0x99uy; 0x36uy; 0x1euy; 0x58uy; 0x79uy; 0x5euy; 0xd4uy; 0x29uy; 0xf7uy; 0x33uy; 0x93uy; 0x48uy; 0xdbuy; 0x5fuy; 0x01uy; 0xaeuy; 0x9cuy; 0xb6uy; 0xe4uy; 0x88uy; 0x6duy; 0x2buy; 0x76uy; 0x75uy; 0xe0uy; 0xf3uy; 0x74uy; 0xe2uy; 0xc9uy; ] in
assert_norm (List.Tot.length l = 63);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad11_len: (x:UInt32.t { UInt32.v x = B.length aad11 }) =
63ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Chacha20Poly1305.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b:
LowStar.Buffer.buffer FStar.UInt8.t
{ LowStar.Monotonic.Buffer.length b = 2011 /\ LowStar.Monotonic.Buffer.recallable b /\
LowStar.Monotonic.Buffer.disjoint b Test.Vectors.Chacha20Poly1305.aad11 } | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"Test.Vectors.Chacha20Poly1305.aad11",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil",
"LowStar.Monotonic.Buffer.recall"
] | [] | false | false | false | false | false | let input11:(b: B.buffer UInt8.t {B.length b = 2011 /\ B.recallable b /\ B.disjoint b aad11}) =
| B.recall aad11;
[@@ inline_let ]let l =
[
0x74uy; 0xa6uy; 0x3euy; 0xe4uy; 0xb1uy; 0xcbuy; 0xafuy; 0xb0uy; 0x40uy; 0xe5uy; 0x0fuy; 0x9euy;
0xf1uy; 0xf2uy; 0x89uy; 0xb5uy; 0x42uy; 0x34uy; 0x8auy; 0xa1uy; 0x03uy; 0xb7uy; 0xe9uy; 0x57uy;
0x46uy; 0xbeuy; 0x20uy; 0xe4uy; 0x6euy; 0xb0uy; 0xebuy; 0xffuy; 0xeauy; 0x07uy; 0x7euy; 0xefuy;
0xe2uy; 0x55uy; 0x9fuy; 0xe5uy; 0x78uy; 0x3auy; 0xb7uy; 0x83uy; 0xc2uy; 0x18uy; 0x40uy; 0x7buy;
0xebuy; 0xcduy; 0x81uy; 0xfbuy; 0x90uy; 0x12uy; 0x9euy; 0x46uy; 0xa9uy; 0xd6uy; 0x4auy; 0xbauy;
0xb0uy; 0x62uy; 0xdbuy; 0x6buy; 0x99uy; 0xc4uy; 0xdbuy; 0x54uy; 0x4buy; 0xb8uy; 0xa5uy; 0x71uy;
0xcbuy; 0xcduy; 0x63uy; 0x32uy; 0x55uy; 0xfbuy; 0x31uy; 0xf0uy; 0x38uy; 0xf5uy; 0xbeuy; 0x78uy;
0xe4uy; 0x45uy; 0xceuy; 0x1buy; 0x6auy; 0x5buy; 0x0euy; 0xf4uy; 0x16uy; 0xe4uy; 0xb1uy; 0x3duy;
0xf6uy; 0x63uy; 0x7buy; 0xa7uy; 0x0cuy; 0xdeuy; 0x6fuy; 0x8fuy; 0x74uy; 0xdfuy; 0xe0uy; 0x1euy;
0x9duy; 0xceuy; 0x8fuy; 0x24uy; 0xefuy; 0x23uy; 0x35uy; 0x33uy; 0x7buy; 0x83uy; 0x34uy; 0x23uy;
0x58uy; 0x74uy; 0x14uy; 0x77uy; 0x1fuy; 0xc2uy; 0x4fuy; 0x4euy; 0xc6uy; 0x89uy; 0xf9uy; 0x52uy;
0x09uy; 0x37uy; 0x64uy; 0x14uy; 0xc4uy; 0x01uy; 0x6buy; 0x9duy; 0x77uy; 0xe8uy; 0x90uy; 0x5duy;
0xa8uy; 0x4auy; 0x2auy; 0xefuy; 0x5cuy; 0x7fuy; 0xebuy; 0xbbuy; 0xb2uy; 0xc6uy; 0x93uy; 0x99uy;
0x66uy; 0xdcuy; 0x7fuy; 0xd4uy; 0x9euy; 0x2auy; 0xcauy; 0x8duy; 0xdbuy; 0xe7uy; 0x20uy; 0xcfuy;
0xe4uy; 0x73uy; 0xaeuy; 0x49uy; 0x7duy; 0x64uy; 0x0fuy; 0x0euy; 0x28uy; 0x46uy; 0xa9uy; 0xa8uy;
0x32uy; 0xe4uy; 0x0euy; 0xf6uy; 0x51uy; 0x53uy; 0xb8uy; 0x3cuy; 0xb1uy; 0xffuy; 0xa3uy; 0x33uy;
0x41uy; 0x75uy; 0xffuy; 0xf1uy; 0x6fuy; 0xf1uy; 0xfbuy; 0xbbuy; 0x83uy; 0x7fuy; 0x06uy; 0x9buy;
0xe7uy; 0x1buy; 0x0auy; 0xe0uy; 0x5cuy; 0x33uy; 0x60uy; 0x5buy; 0xdbuy; 0x5buy; 0xeduy; 0xfeuy;
0xa5uy; 0x16uy; 0x19uy; 0x72uy; 0xa3uy; 0x64uy; 0x23uy; 0x00uy; 0x02uy; 0xc7uy; 0xf3uy; 0x6auy;
0x81uy; 0x3euy; 0x44uy; 0x1duy; 0x79uy; 0x15uy; 0x5fuy; 0x9auy; 0xdeuy; 0xe2uy; 0xfduy; 0x1buy;
0x73uy; 0xc1uy; 0xbcuy; 0x23uy; 0xbauy; 0x31uy; 0xd2uy; 0x50uy; 0xd5uy; 0xaduy; 0x7fuy; 0x74uy;
0xa7uy; 0xc9uy; 0xf8uy; 0x3euy; 0x2buy; 0x26uy; 0x10uy; 0xf6uy; 0x03uy; 0x36uy; 0x74uy; 0xe4uy;
0x0euy; 0x6auy; 0x72uy; 0xb7uy; 0x73uy; 0x0auy; 0x42uy; 0x28uy; 0xc2uy; 0xaduy; 0x5euy; 0x03uy;
0xbeuy; 0xb8uy; 0x0buy; 0xa8uy; 0x5buy; 0xd4uy; 0xb8uy; 0xbauy; 0x52uy; 0x89uy; 0xb1uy; 0x9buy;
0xc1uy; 0xc3uy; 0x65uy; 0x87uy; 0xeduy; 0xa5uy; 0xf4uy; 0x86uy; 0xfduy; 0x41uy; 0x80uy; 0x91uy;
0x27uy; 0x59uy; 0x53uy; 0x67uy; 0x15uy; 0x78uy; 0x54uy; 0x8buy; 0x2duy; 0x3duy; 0xc7uy; 0xffuy;
0x02uy; 0x92uy; 0x07uy; 0x5fuy; 0x7auy; 0x4buy; 0x60uy; 0x59uy; 0x3cuy; 0x6fuy; 0x5cuy; 0xd8uy;
0xecuy; 0x95uy; 0xd2uy; 0xfeuy; 0xa0uy; 0x3buy; 0xd8uy; 0x3fuy; 0xd1uy; 0x69uy; 0xa6uy; 0xd6uy;
0x41uy; 0xb2uy; 0xf4uy; 0x4duy; 0x12uy; 0xf4uy; 0x58uy; 0x3euy; 0x66uy; 0x64uy; 0x80uy; 0x31uy;
0x9buy; 0xa8uy; 0x4cuy; 0x8buy; 0x07uy; 0xb2uy; 0xecuy; 0x66uy; 0x94uy; 0x66uy; 0x47uy; 0x50uy;
0x50uy; 0x5fuy; 0x18uy; 0x0buy; 0x0euy; 0xd6uy; 0xc0uy; 0x39uy; 0x21uy; 0x13uy; 0x9euy; 0x33uy;
0xbcuy; 0x79uy; 0x36uy; 0x02uy; 0x96uy; 0x70uy; 0xf0uy; 0x48uy; 0x67uy; 0x2fuy; 0x26uy; 0xe9uy;
0x6duy; 0x10uy; 0xbbuy; 0xd6uy; 0x3fuy; 0xd1uy; 0x64uy; 0x7auy; 0x2euy; 0xbeuy; 0x0cuy; 0x61uy;
0xf0uy; 0x75uy; 0x42uy; 0x38uy; 0x23uy; 0xb1uy; 0x9euy; 0x9fuy; 0x7cuy; 0x67uy; 0x66uy; 0xd9uy;
0x58uy; 0x9auy; 0xf1uy; 0xbbuy; 0x41uy; 0x2auy; 0x8duy; 0x65uy; 0x84uy; 0x94uy; 0xfcuy; 0xdcuy;
0x6auy; 0x50uy; 0x64uy; 0xdbuy; 0x56uy; 0x33uy; 0x76uy; 0x00uy; 0x10uy; 0xeduy; 0xbeuy; 0xd2uy;
0x12uy; 0xf6uy; 0xf6uy; 0x1buy; 0xa2uy; 0x16uy; 0xdeuy; 0xaeuy; 0x31uy; 0x95uy; 0xdduy; 0xb1uy;
0x08uy; 0x7euy; 0x4euy; 0xeeuy; 0xe7uy; 0xf9uy; 0xa5uy; 0xfbuy; 0x5buy; 0x61uy; 0x43uy; 0x00uy;
0x40uy; 0xf6uy; 0x7euy; 0x02uy; 0x04uy; 0x32uy; 0x4euy; 0x0cuy; 0xe2uy; 0x66uy; 0x0duy; 0xd7uy;
0x07uy; 0x98uy; 0x0euy; 0xf8uy; 0x72uy; 0x34uy; 0x6duy; 0x95uy; 0x86uy; 0xd7uy; 0xcbuy; 0x31uy;
0x54uy; 0x47uy; 0xd0uy; 0x38uy; 0x29uy; 0x9cuy; 0x5auy; 0x68uy; 0xd4uy; 0x87uy; 0x76uy; 0xc9uy;
0xe7uy; 0x7euy; 0xe3uy; 0xf4uy; 0x81uy; 0x6duy; 0x18uy; 0xcbuy; 0xc9uy; 0x05uy; 0xafuy; 0xa0uy;
0xfbuy; 0x66uy; 0xf7uy; 0xf1uy; 0x1cuy; 0xc6uy; 0x14uy; 0x11uy; 0x4fuy; 0x2buy; 0x79uy; 0x42uy;
0x8buy; 0xbcuy; 0xacuy; 0xe7uy; 0x6cuy; 0xfeuy; 0x0fuy; 0x58uy; 0xe7uy; 0x7cuy; 0x78uy; 0x39uy;
0x30uy; 0xb0uy; 0x66uy; 0x2cuy; 0x9buy; 0x6duy; 0x3auy; 0xe1uy; 0xcfuy; 0xc9uy; 0xa4uy; 0x0euy;
0x6duy; 0x6duy; 0x8auy; 0xa1uy; 0x3auy; 0xe7uy; 0x28uy; 0xd4uy; 0x78uy; 0x4cuy; 0xa6uy; 0xa2uy;
0x2auy; 0xa6uy; 0x03uy; 0x30uy; 0xd7uy; 0xa8uy; 0x25uy; 0x66uy; 0x87uy; 0x2fuy; 0x69uy; 0x5cuy;
0x4euy; 0xdduy; 0xa5uy; 0x49uy; 0x5duy; 0x37uy; 0x4auy; 0x59uy; 0xc4uy; 0xafuy; 0x1fuy; 0xa2uy;
0xe4uy; 0xf8uy; 0xa6uy; 0x12uy; 0x97uy; 0xd5uy; 0x79uy; 0xf5uy; 0xe2uy; 0x4auy; 0x2buy; 0x5fuy;
0x61uy; 0xe4uy; 0x9euy; 0xe3uy; 0xeeuy; 0xb8uy; 0xa7uy; 0x5buy; 0x2fuy; 0xf4uy; 0x9euy; 0x6cuy;
0xfbuy; 0xd1uy; 0xc6uy; 0x56uy; 0x77uy; 0xbauy; 0x75uy; 0xaauy; 0x3duy; 0x1auy; 0xa8uy; 0x0buy;
0xb3uy; 0x68uy; 0x24uy; 0x00uy; 0x10uy; 0x7fuy; 0xfduy; 0xd7uy; 0xa1uy; 0x8duy; 0x83uy; 0x54uy;
0x4fuy; 0x1fuy; 0xd8uy; 0x2auy; 0xbeuy; 0x8auy; 0x0cuy; 0x87uy; 0xabuy; 0xa2uy; 0xdeuy; 0xc3uy;
0x39uy; 0xbfuy; 0x09uy; 0x03uy; 0xa5uy; 0xf3uy; 0x05uy; 0x28uy; 0xe1uy; 0xe1uy; 0xeeuy; 0x39uy;
0x70uy; 0x9cuy; 0xd8uy; 0x81uy; 0x12uy; 0x1euy; 0x02uy; 0x40uy; 0xd2uy; 0x6euy; 0xf0uy; 0xebuy;
0x1buy; 0x3duy; 0x22uy; 0xc6uy; 0xe5uy; 0xe3uy; 0xb4uy; 0x5auy; 0x98uy; 0xbbuy; 0xf0uy; 0x22uy;
0x28uy; 0x8duy; 0xe5uy; 0xd3uy; 0x16uy; 0x48uy; 0x24uy; 0xa5uy; 0xe6uy; 0x66uy; 0x0cuy; 0xf9uy;
0x08uy; 0xf9uy; 0x7euy; 0x1euy; 0xe1uy; 0x28uy; 0x26uy; 0x22uy; 0xc7uy; 0xc7uy; 0x0auy; 0x32uy;
0x47uy; 0xfauy; 0xa3uy; 0xbeuy; 0x3cuy; 0xc4uy; 0xc5uy; 0x53uy; 0x0auy; 0xd5uy; 0x94uy; 0x4auy;
0xd7uy; 0x93uy; 0xd8uy; 0x42uy; 0x99uy; 0xb9uy; 0x0auy; 0xdbuy; 0x56uy; 0xf7uy; 0xb9uy; 0x1cuy;
0x53uy; 0x4fuy; 0xfauy; 0xd3uy; 0x74uy; 0xaduy; 0xd9uy; 0x68uy; 0xf1uy; 0x1buy; 0xdfuy; 0x61uy;
0xc6uy; 0x5euy; 0xa8uy; 0x48uy; 0xfcuy; 0xd4uy; 0x4auy; 0x4cuy; 0x3cuy; 0x32uy; 0xf7uy; 0x1cuy;
0x96uy; 0x21uy; 0x9buy; 0xf9uy; 0xa3uy; 0xccuy; 0x5auy; 0xceuy; 0xd5uy; 0xd7uy; 0x08uy; 0x24uy;
0xf6uy; 0x1cuy; 0xfduy; 0xdduy; 0x38uy; 0xc2uy; 0x32uy; 0xe9uy; 0xb8uy; 0xe7uy; 0xb6uy; 0xfauy;
0x9duy; 0x45uy; 0x13uy; 0x2cuy; 0x83uy; 0xfduy; 0x4auy; 0x69uy; 0x82uy; 0xcduy; 0xdcuy; 0xb3uy;
0x76uy; 0x0cuy; 0x9euy; 0xd8uy; 0xf4uy; 0x1buy; 0x45uy; 0x15uy; 0xb4uy; 0x97uy; 0xe7uy; 0x58uy;
0x34uy; 0xe2uy; 0x03uy; 0x29uy; 0x5auy; 0xbfuy; 0xb6uy; 0xe0uy; 0x5duy; 0x13uy; 0xd9uy; 0x2buy;
0xb4uy; 0x80uy; 0xb2uy; 0x45uy; 0x81uy; 0x6auy; 0x2euy; 0x6cuy; 0x89uy; 0x7duy; 0xeeuy; 0xbbuy;
0x52uy; 0xdduy; 0x1fuy; 0x18uy; 0xe7uy; 0x13uy; 0x6buy; 0x33uy; 0x0euy; 0xeauy; 0x36uy; 0x92uy;
0x77uy; 0x7buy; 0x6duy; 0x9cuy; 0x5auy; 0x5fuy; 0x45uy; 0x7buy; 0x7buy; 0x35uy; 0x62uy; 0x23uy;
0xd1uy; 0xbfuy; 0x0fuy; 0xd0uy; 0x08uy; 0x1buy; 0x2buy; 0x80uy; 0x6buy; 0x7euy; 0xf1uy; 0x21uy;
0x47uy; 0xb0uy; 0x57uy; 0xd1uy; 0x98uy; 0x72uy; 0x90uy; 0x34uy; 0x1cuy; 0x20uy; 0x04uy; 0xffuy;
0x3duy; 0x5cuy; 0xeeuy; 0x0euy; 0x57uy; 0x5fuy; 0x6fuy; 0x24uy; 0x4euy; 0x3cuy; 0xeauy; 0xfcuy;
0xa5uy; 0xa9uy; 0x83uy; 0xc9uy; 0x61uy; 0xb4uy; 0x51uy; 0x24uy; 0xf8uy; 0x27uy; 0x5euy; 0x46uy;
0x8cuy; 0xb1uy; 0x53uy; 0x02uy; 0x96uy; 0x35uy; 0xbauy; 0xb8uy; 0x4cuy; 0x71uy; 0xd3uy; 0x15uy;
0x59uy; 0x35uy; 0x22uy; 0x20uy; 0xaduy; 0x03uy; 0x9fuy; 0x66uy; 0x44uy; 0x3buy; 0x9cuy; 0x35uy;
0x37uy; 0x1fuy; 0x9buy; 0xbbuy; 0xf3uy; 0xdbuy; 0x35uy; 0x63uy; 0x30uy; 0x64uy; 0xaauy; 0xa2uy;
0x06uy; 0xa8uy; 0x5duy; 0xbbuy; 0xe1uy; 0x9fuy; 0x70uy; 0xecuy; 0x82uy; 0x11uy; 0x06uy; 0x36uy;
0xecuy; 0x8buy; 0x69uy; 0x66uy; 0x24uy; 0x44uy; 0xc9uy; 0x4auy; 0x57uy; 0xbbuy; 0x9buy; 0x78uy;
0x13uy; 0xceuy; 0x9cuy; 0x0cuy; 0xbauy; 0x92uy; 0x93uy; 0x63uy; 0xb8uy; 0xe2uy; 0x95uy; 0x0fuy;
0x0fuy; 0x16uy; 0x39uy; 0x52uy; 0xfduy; 0x3auy; 0x6duy; 0x02uy; 0x4buy; 0xdfuy; 0x13uy; 0xd3uy;
0x2auy; 0x22uy; 0xb4uy; 0x03uy; 0x7cuy; 0x54uy; 0x49uy; 0x96uy; 0x68uy; 0x54uy; 0x10uy; 0xfauy;
0xefuy; 0xaauy; 0x6cuy; 0xe8uy; 0x22uy; 0xdcuy; 0x71uy; 0x16uy; 0x13uy; 0x1auy; 0xf6uy; 0x28uy;
0xe5uy; 0x6duy; 0x77uy; 0x3duy; 0xcduy; 0x30uy; 0x63uy; 0xb1uy; 0x70uy; 0x52uy; 0xa1uy; 0xc5uy;
0x94uy; 0x5fuy; 0xcfuy; 0xe8uy; 0xb8uy; 0x26uy; 0x98uy; 0xf7uy; 0x06uy; 0xa0uy; 0x0auy; 0x70uy;
0xfauy; 0x03uy; 0x80uy; 0xacuy; 0xc1uy; 0xecuy; 0xd6uy; 0x4cuy; 0x54uy; 0xd7uy; 0xfeuy; 0x47uy;
0xb6uy; 0x88uy; 0x4auy; 0xf7uy; 0x71uy; 0x24uy; 0xeeuy; 0xf3uy; 0xd2uy; 0xc2uy; 0x4auy; 0x7fuy;
0xfeuy; 0x61uy; 0xc7uy; 0x35uy; 0xc9uy; 0x37uy; 0x67uy; 0xcbuy; 0x24uy; 0x35uy; 0xdauy; 0x7euy;
0xcauy; 0x5fuy; 0xf3uy; 0x8duy; 0xd4uy; 0x13uy; 0x8euy; 0xd6uy; 0xcbuy; 0x4duy; 0x53uy; 0x8fuy;
0x53uy; 0x1fuy; 0xc0uy; 0x74uy; 0xf7uy; 0x53uy; 0xb9uy; 0x5euy; 0x23uy; 0x37uy; 0xbauy; 0x6euy;
0xe3uy; 0x9duy; 0x07uy; 0x55uy; 0x25uy; 0x7buy; 0xe6uy; 0x2auy; 0x64uy; 0xd1uy; 0x32uy; 0xdduy;
0x54uy; 0x1buy; 0x4buy; 0xc0uy; 0xe1uy; 0xd7uy; 0x69uy; 0x58uy; 0xf8uy; 0x93uy; 0x29uy; 0xc4uy;
0xdduy; 0x23uy; 0x2fuy; 0xa5uy; 0xfcuy; 0x9duy; 0x7euy; 0xf8uy; 0xd4uy; 0x90uy; 0xcduy; 0x82uy;
0x55uy; 0xdcuy; 0x16uy; 0x16uy; 0x9fuy; 0x07uy; 0x52uy; 0x9buy; 0x9duy; 0x25uy; 0xeduy; 0x32uy;
0xc5uy; 0x7buy; 0xdfuy; 0xf6uy; 0x83uy; 0x46uy; 0x3duy; 0x65uy; 0xb7uy; 0xefuy; 0x87uy; 0x7auy;
0x12uy; 0x69uy; 0x8fuy; 0x06uy; 0x7cuy; 0x51uy; 0x15uy; 0x4auy; 0x08uy; 0xe8uy; 0xacuy; 0x9auy;
0x0cuy; 0x24uy; 0xa7uy; 0x27uy; 0xd8uy; 0x46uy; 0x2fuy; 0xe7uy; 0x01uy; 0x0euy; 0x1cuy; 0xc6uy;
0x91uy; 0xb0uy; 0x6euy; 0x85uy; 0x65uy; 0xf0uy; 0x29uy; 0x0duy; 0x2euy; 0x6buy; 0x3buy; 0xfbuy;
0x4buy; 0xdfuy; 0xe4uy; 0x80uy; 0x93uy; 0x03uy; 0x66uy; 0x46uy; 0x3euy; 0x8auy; 0x6euy; 0xf3uy;
0x5euy; 0x4duy; 0x62uy; 0x0euy; 0x49uy; 0x05uy; 0xafuy; 0xd4uy; 0xf8uy; 0x21uy; 0x20uy; 0x61uy;
0x1duy; 0x39uy; 0x17uy; 0xf4uy; 0x61uy; 0x47uy; 0x95uy; 0xfbuy; 0x15uy; 0x2euy; 0xb3uy; 0x4fuy;
0xd0uy; 0x5duy; 0xf5uy; 0x7duy; 0x40uy; 0xdauy; 0x90uy; 0x3cuy; 0x6buy; 0xcbuy; 0x17uy; 0x00uy;
0x13uy; 0x3buy; 0x64uy; 0x34uy; 0x1buy; 0xf0uy; 0xf2uy; 0xe5uy; 0x3buy; 0xb2uy; 0xc7uy; 0xd3uy;
0x5fuy; 0x3auy; 0x44uy; 0xa6uy; 0x9buy; 0xb7uy; 0x78uy; 0x0euy; 0x42uy; 0x5duy; 0x4cuy; 0xc1uy;
0xe9uy; 0xd2uy; 0xcbuy; 0xb7uy; 0x78uy; 0xd1uy; 0xfeuy; 0x9auy; 0xb5uy; 0x07uy; 0xe9uy; 0xe0uy;
0xbeuy; 0xe2uy; 0x8auy; 0xa7uy; 0x01uy; 0x83uy; 0x00uy; 0x8cuy; 0x5cuy; 0x08uy; 0xe6uy; 0x63uy;
0x12uy; 0x92uy; 0xb7uy; 0xb7uy; 0xa6uy; 0x19uy; 0x7duy; 0x38uy; 0x13uy; 0x38uy; 0x92uy; 0x87uy;
0x24uy; 0xf9uy; 0x48uy; 0xb3uy; 0x5euy; 0x87uy; 0x6auy; 0x40uy; 0x39uy; 0x5cuy; 0x3fuy; 0xeduy;
0x8fuy; 0xeeuy; 0xdbuy; 0x15uy; 0x82uy; 0x06uy; 0xdauy; 0x49uy; 0x21uy; 0x2buy; 0xb5uy; 0xbfuy;
0x32uy; 0x7cuy; 0x9fuy; 0x42uy; 0x28uy; 0x63uy; 0xcfuy; 0xafuy; 0x1euy; 0xf8uy; 0xc6uy; 0xa0uy;
0xd1uy; 0x02uy; 0x43uy; 0x57uy; 0x62uy; 0xecuy; 0x9buy; 0x0fuy; 0x01uy; 0x9euy; 0x71uy; 0xd8uy;
0x87uy; 0x9duy; 0x01uy; 0xc1uy; 0x58uy; 0x77uy; 0xd9uy; 0xafuy; 0xb1uy; 0x10uy; 0x7euy; 0xdduy;
0xa6uy; 0x50uy; 0x96uy; 0xe5uy; 0xf0uy; 0x72uy; 0x00uy; 0x6duy; 0x4buy; 0xf8uy; 0x2auy; 0x8fuy;
0x19uy; 0xf3uy; 0x22uy; 0x88uy; 0x11uy; 0x4auy; 0x8buy; 0x7cuy; 0xfduy; 0xb7uy; 0xeduy; 0xe1uy;
0xf6uy; 0x40uy; 0x39uy; 0xe0uy; 0xe9uy; 0xf6uy; 0x3duy; 0x25uy; 0xe6uy; 0x74uy; 0x3cuy; 0x58uy;
0x57uy; 0x7fuy; 0xe1uy; 0x22uy; 0x96uy; 0x47uy; 0x31uy; 0x91uy; 0xbauy; 0x70uy; 0x85uy; 0x28uy;
0x6buy; 0x9fuy; 0x6euy; 0x25uy; 0xacuy; 0x23uy; 0x66uy; 0x2fuy; 0x29uy; 0x88uy; 0x28uy; 0xceuy;
0x8cuy; 0x5cuy; 0x88uy; 0x53uy; 0xd1uy; 0x3buy; 0xccuy; 0x6auy; 0x51uy; 0xb2uy; 0xe1uy; 0x28uy;
0x3fuy; 0x91uy; 0xb4uy; 0x0duy; 0x00uy; 0x3auy; 0xe3uy; 0xf8uy; 0xc3uy; 0x8fuy; 0xd7uy; 0x96uy;
0x62uy; 0x0euy; 0x2euy; 0xfcuy; 0xc8uy; 0x6cuy; 0x77uy; 0xa6uy; 0x1duy; 0x22uy; 0xc1uy; 0xb8uy;
0xe6uy; 0x61uy; 0xd7uy; 0x67uy; 0x36uy; 0x13uy; 0x7buy; 0xbbuy; 0x9buy; 0x59uy; 0x09uy; 0xa6uy;
0xdfuy; 0xf7uy; 0x6buy; 0xa3uy; 0x40uy; 0x1auy; 0xf5uy; 0x4fuy; 0xb4uy; 0xdauy; 0xd3uy; 0xf3uy;
0x81uy; 0x93uy; 0xc6uy; 0x18uy; 0xd9uy; 0x26uy; 0xeeuy; 0xacuy; 0xf0uy; 0xaauy; 0xdfuy; 0xc5uy;
0x9cuy; 0xcauy; 0xc2uy; 0xa2uy; 0xccuy; 0x7buy; 0x5cuy; 0x24uy; 0xb0uy; 0xbcuy; 0xd0uy; 0x6auy;
0x4duy; 0x89uy; 0x09uy; 0xb8uy; 0x07uy; 0xfeuy; 0x87uy; 0xaduy; 0x0auy; 0xeauy; 0xb8uy; 0x42uy;
0xf9uy; 0x5euy; 0xb3uy; 0x3euy; 0x36uy; 0x4cuy; 0xafuy; 0x75uy; 0x9euy; 0x1cuy; 0xebuy; 0xbduy;
0xbcuy; 0xbbuy; 0x80uy; 0x40uy; 0xa7uy; 0x3auy; 0x30uy; 0xbfuy; 0xa8uy; 0x44uy; 0xf4uy; 0xebuy;
0x38uy; 0xaduy; 0x29uy; 0xbauy; 0x23uy; 0xeduy; 0x41uy; 0x0cuy; 0xeauy; 0xd2uy; 0xbbuy; 0x41uy;
0x18uy; 0xd6uy; 0xb9uy; 0xbauy; 0x65uy; 0x2buy; 0xa3uy; 0x91uy; 0x6duy; 0x1fuy; 0xa9uy; 0xf4uy;
0xd1uy; 0x25uy; 0x8duy; 0x4duy; 0x38uy; 0xffuy; 0x64uy; 0xa0uy; 0xecuy; 0xdeuy; 0xa6uy; 0xb6uy;
0x79uy; 0xabuy; 0x8euy; 0x33uy; 0x6cuy; 0x47uy; 0xdeuy; 0xafuy; 0x94uy; 0xa4uy; 0xa5uy; 0x86uy;
0x77uy; 0x55uy; 0x09uy; 0x92uy; 0x81uy; 0x31uy; 0x76uy; 0xc7uy; 0x34uy; 0x22uy; 0x89uy; 0x8euy;
0x3duy; 0x26uy; 0x26uy; 0xd7uy; 0xfcuy; 0x1euy; 0x16uy; 0x72uy; 0x13uy; 0x33uy; 0x63uy; 0xd5uy;
0x22uy; 0xbeuy; 0xb8uy; 0x04uy; 0x34uy; 0x84uy; 0x41uy; 0xbbuy; 0x80uy; 0xd0uy; 0x9fuy; 0x46uy;
0x48uy; 0x07uy; 0xa7uy; 0xfcuy; 0x2buy; 0x3auy; 0x75uy; 0x55uy; 0x8cuy; 0xc7uy; 0x6auy; 0xbduy;
0x7euy; 0x46uy; 0x08uy; 0x84uy; 0x0fuy; 0xd5uy; 0x74uy; 0xc0uy; 0x82uy; 0x8euy; 0xaauy; 0x61uy;
0x05uy; 0x01uy; 0xb2uy; 0x47uy; 0x6euy; 0x20uy; 0x6auy; 0x2duy; 0x58uy; 0x70uy; 0x48uy; 0x32uy;
0xa7uy; 0x37uy; 0xd2uy; 0xb8uy; 0x82uy; 0x1auy; 0x51uy; 0xb9uy; 0x61uy; 0xdduy; 0xfduy; 0x9duy;
0x6buy; 0x0euy; 0x18uy; 0x97uy; 0xf8uy; 0x45uy; 0x5fuy; 0x87uy; 0x10uy; 0xcfuy; 0x34uy; 0x72uy;
0x45uy; 0x26uy; 0x49uy; 0x70uy; 0xe7uy; 0xa3uy; 0x78uy; 0xe0uy; 0x52uy; 0x89uy; 0x84uy; 0x94uy;
0x83uy; 0x82uy; 0xc2uy; 0x69uy; 0x8fuy; 0xe3uy; 0xe1uy; 0x3fuy; 0x60uy; 0x74uy; 0x88uy; 0xc4uy;
0xf7uy; 0x75uy; 0x2cuy; 0xfbuy; 0xbduy; 0xb6uy; 0xc4uy; 0x7euy; 0x10uy; 0x0auy; 0x6cuy; 0x90uy;
0x04uy; 0x9euy; 0xc3uy; 0x3fuy; 0x59uy; 0x7cuy; 0xceuy; 0x31uy; 0x18uy; 0x60uy; 0x57uy; 0x73uy;
0x46uy; 0x94uy; 0x7duy; 0x06uy; 0xa0uy; 0x6duy; 0x44uy; 0xecuy; 0xa2uy; 0x0auy; 0x9euy; 0x05uy;
0x15uy; 0xefuy; 0xcauy; 0x5cuy; 0xbfuy; 0x00uy; 0xebuy; 0xf7uy; 0x3duy; 0x32uy; 0xd4uy; 0xa5uy;
0xefuy; 0x49uy; 0x89uy; 0x5euy; 0x46uy; 0xb0uy; 0xa6uy; 0x63uy; 0x5buy; 0x8auy; 0x73uy; 0xaeuy;
0x6fuy; 0xd5uy; 0x9duy; 0xf8uy; 0x4fuy; 0x40uy; 0xb5uy; 0xb2uy; 0x6euy; 0xd3uy; 0xb6uy; 0x01uy;
0xa9uy; 0x26uy; 0xa2uy; 0x21uy; 0xcfuy; 0x33uy; 0x7auy; 0x3auy; 0xa4uy; 0x23uy; 0x13uy; 0xb0uy;
0x69uy; 0x6auy; 0xeeuy; 0xceuy; 0xd8uy; 0x9duy; 0x01uy; 0x1duy; 0x50uy; 0xc1uy; 0x30uy; 0x6cuy;
0xb1uy; 0xcduy; 0xa0uy; 0xf0uy; 0xf0uy; 0xa2uy; 0x64uy; 0x6fuy; 0xbbuy; 0xbfuy; 0x5euy; 0xe6uy;
0xabuy; 0x87uy; 0xb4uy; 0x0fuy; 0x4fuy; 0x15uy; 0xafuy; 0xb5uy; 0x25uy; 0xa1uy; 0xb2uy; 0xd0uy;
0x80uy; 0x2cuy; 0xfbuy; 0xf9uy; 0xfeuy; 0xd2uy; 0x33uy; 0xbbuy; 0x76uy; 0xfeuy; 0x7cuy; 0xa8uy;
0x66uy; 0xf7uy; 0xe7uy; 0x85uy; 0x9fuy; 0x1fuy; 0x85uy; 0x57uy; 0x88uy; 0xe1uy; 0xe9uy; 0x63uy;
0xe4uy; 0xd8uy; 0x1cuy; 0xa1uy; 0xfbuy; 0xdauy; 0x44uy; 0x05uy; 0x2euy; 0x1duy; 0x3auy; 0x1cuy;
0xffuy; 0xc8uy; 0x3buy; 0xc0uy; 0xfeuy; 0xdauy; 0x22uy; 0x0buy; 0x43uy; 0xd6uy; 0x88uy; 0x39uy;
0x4cuy; 0x4auy; 0xa6uy; 0x69uy; 0x18uy; 0x93uy; 0x42uy; 0x4euy; 0xb5uy; 0xccuy; 0x66uy; 0x0duy;
0x09uy; 0xf8uy; 0x1euy; 0x7cuy; 0xd3uy; 0x3cuy; 0x99uy; 0x0duy; 0x50uy; 0x1duy; 0x62uy; 0xe9uy;
0x57uy; 0x06uy; 0xbfuy; 0x19uy; 0x88uy; 0xdduy; 0xaduy; 0x7buy; 0x4fuy; 0xf9uy; 0xc7uy; 0x82uy;
0x6duy; 0x8duy; 0xc8uy; 0xc4uy; 0xc5uy; 0x78uy; 0x17uy; 0x20uy; 0x15uy; 0xc5uy; 0x52uy; 0x41uy;
0xcfuy; 0x5buy; 0xd6uy; 0x7fuy; 0x94uy; 0x02uy; 0x41uy; 0xe0uy; 0x40uy; 0x22uy; 0x03uy; 0x5euy;
0xd1uy; 0x53uy; 0xd4uy; 0x86uy; 0xd3uy; 0x2cuy; 0x9fuy; 0x0fuy; 0x96uy; 0xe3uy; 0x6buy; 0x9auy;
0x76uy; 0x32uy; 0x06uy; 0x47uy; 0x4buy; 0x11uy; 0xb3uy; 0xdduy; 0x03uy; 0x65uy; 0xbduy; 0x9buy;
0x01uy; 0xdauy; 0x9cuy; 0xb9uy; 0x7euy; 0x3fuy; 0x6auy; 0xc4uy; 0x7buy; 0xeauy; 0xd4uy; 0x3cuy;
0xb9uy; 0xfbuy; 0x5cuy; 0x6buy; 0x64uy; 0x33uy; 0x52uy; 0xbauy; 0x64uy; 0x78uy; 0x8fuy; 0xa4uy;
0xafuy; 0x7auy; 0x61uy; 0x8duy; 0xbcuy; 0xc5uy; 0x73uy; 0xe9uy; 0x6buy; 0x58uy; 0x97uy; 0x4buy;
0xbfuy; 0x63uy; 0x22uy; 0xd3uy; 0x37uy; 0x02uy; 0x54uy; 0xc5uy; 0xb9uy; 0x16uy; 0x4auy; 0xf0uy;
0x19uy; 0xd8uy; 0x94uy; 0x57uy; 0xb8uy; 0x8auy; 0xb3uy; 0x16uy; 0x3buy; 0xd0uy; 0x84uy; 0x8euy;
0x67uy; 0xa6uy; 0xa3uy; 0x7duy; 0x78uy; 0xecuy; 0x00uy
]
in
assert_norm (List.Tot.length l = 2011);
B.gcmalloc_of_list HyperStack.root l | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VPaddd | val va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 125,
"start_col": 0,
"start_line": 119
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Arch.Types.add_wrap_quad32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pxor | val va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 158,
"start_col": 0,
"start_line": 153
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"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.quad32_xor",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VPxor | val va_wp_VPxor
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VPxor
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 78,
"end_line": 229,
"start_col": 0,
"start_line": 224
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Vale.X64.Decls.va_is_src_opr128",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"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.quad32_xor",
"Vale.X64.Decls.va_eval_opr128",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VPxor
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(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 /\
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pand | val va_wp_Pand
(dst: va_operand_xmm)
(src: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pand
(dst: va_operand_xmm)
(src: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 193,
"start_col": 0,
"start_line": 187
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_opr128",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words.Four_s.four_map2",
"Vale.X64.Memory.nat32",
"Vale.Arch.Types.iand32",
"Vale.X64.Decls.va_eval_opr128",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pand
(dst: va_operand_xmm)
(src: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Psrld | val va_wp_Psrld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Psrld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 296,
"start_col": 0,
"start_line": 291
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words.Four_s.four_map",
"Vale.X64.Memory.nat32",
"Vale.Arch.Types.ishr32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Psrld
(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 < 32) /\
(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 /\
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Paddd | val va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 88,
"start_col": 0,
"start_line": 82
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Arch.Types.add_wrap_quad32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pslld | val va_wp_Pslld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pslld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 263,
"start_col": 0,
"start_line": 258
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words.Four_s.four_map",
"Vale.X64.Memory.nat32",
"Vale.Arch.Types.ishl32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pslld
(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 < 32) /\
(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 /\
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VPalignr8 | val va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 420,
"start_col": 0,
"start_line": 411
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st | val rsapss_check_exponent_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e)) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 114,
"start_col": 0,
"start_line": 108
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.modifies0",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.RSAPSS.rsapss_check_exponent",
"Lib.Buffer.as_seq"
] | [] | false | false | false | true | true | let rsapss_check_exponent_st (t: limb_t) =
|
eBits: size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t} ->
e: lbignum t (blocks eBits (size (bits t)))
-> Stack (limb t)
(requires fun h -> live h e)
(ensures
fun h0 r h1 -> modifies0 h0 h1 /\ r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e)) | false |
|
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Palignr4 | val va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 335,
"start_col": 0,
"start_line": 327
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st | val bn_check_num_bits_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b)) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 71,
"start_col": 0,
"start_line": 65
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.modifies0",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.RSAPSS.bn_check_num_bits",
"Lib.Buffer.as_seq"
] | [] | false | false | false | true | true | let bn_check_num_bits_st (t: limb_t) =
|
bs: size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t} ->
b: lbignum t (blocks bs (size (bits t)))
-> Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == LS.bn_check_num_bits (v bs) (as_seq h0 b)) | false |
|
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st | val rsapss_check_modulus_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n)) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 89,
"start_col": 0,
"start_line": 83
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.modifies0",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.RSAPSS.rsapss_check_modulus",
"Lib.Buffer.as_seq"
] | [] | false | false | false | true | true | let rsapss_check_modulus_st (t: limb_t) =
|
modBits: size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t} ->
n: lbignum t (blocks modBits (size (bits t)))
-> Stack (limb t)
(requires fun h -> live h n)
(ensures
fun h0 r h1 -> modifies0 h0 h1 /\ r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n)) | false |
|
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Palignr8 | val va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 375,
"start_col": 0,
"start_line": 367
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Shufpd | val va_wp_Shufpd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Shufpd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 473,
"start_col": 0,
"start_line": 458
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.op_LessThan",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.X64.Decls.va_if",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Prims.l_not",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Shufpd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
va_eval_xmm va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(va_if (permutation = 0 || permutation = 2)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)))
(va_if (permutation = 0 || permutation = 2)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)))
(va_if (permutation = 0 || permutation = 1)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src)))
(va_if (permutation = 0 || permutation = 1)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VPshufb | val va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 88,
"end_line": 605,
"start_col": 0,
"start_line": 598
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks | val mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t | val mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t | let mk_runtime_rsapss_checks (#t:limb_t) : rsapss_checks t =
match t with
| U32 -> mk_runtime_rsapss_checks_uint32
| U64 -> mk_runtime_rsapss_checks_uint64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 179,
"start_col": 0,
"start_line": 176
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits
[@CInline]
let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64
[@CInline]
let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint64: rsapss_checks U64
let mk_runtime_rsapss_checks_uint64 = {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64;
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.rsapss_checks t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint32",
"Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint64",
"Hacl.Impl.RSAPSS.Keys.rsapss_checks"
] | [] | false | false | false | false | false | let mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t =
| match t with
| U32 -> mk_runtime_rsapss_checks_uint32
| U64 -> mk_runtime_rsapss_checks_uint64 | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.buffer128_write | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 25,
"start_col": 0,
"start_line": 21
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Vale.X64.Memory.buffer128 ->
i: Prims.int ->
v: Vale.X64.Decls.quad32 ->
h: Vale.X64.InsBasic.vale_heap
-> Prims.Ghost Vale.X64.InsBasic.vale_heap | Prims.Ghost | [] | [] | [
"Vale.X64.Memory.buffer128",
"Prims.int",
"Vale.X64.Decls.quad32",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.buffer_write",
"Vale.X64.Memory.vuint128",
"Prims.l_and",
"Vale.X64.Decls.buffer_readable",
"Vale.X64.Decls.buffer_writeable",
"Prims.l_True"
] | [] | false | false | false | false | false | let buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) =
| buffer_write b i v h | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Mem128_lemma | val va_wp_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))
: Type0 | val va_wp_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))
: Type0 | let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 53,
"start_col": 0,
"start_line": 45
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.X64.Decls.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.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",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Machine_s.uu___is_OReg",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Decls.valid_src_addr",
"Vale.X64.Memory.vuint128",
"Vale.X64.Memory.valid_layout_buffer",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Prims.op_Addition",
"Vale.X64.State.eval_operand",
"Vale.X64.Memory.buffer_addr",
"Prims.op_Multiply",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.X64.Decls.va_get_mem_heaplet",
"Prims.l_imp",
"Vale.X64.Decls.valid_operand128",
"Vale.X64.Decls.va_opr_code_Mem128",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Memory.load_mem128",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.Memory.buffer_read",
"Vale.X64.State.vale_state"
] | [] | false | false | false | true | true | let va_wp_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))
: Type0 =
| (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) /\
(let va_sM = va_s0 in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VShufpd | val va_wp_VShufpd
(dst src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VShufpd
(dst src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 528,
"start_col": 0,
"start_line": 513
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.op_LessThan",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.X64.Decls.va_if",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Prims.l_not",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VShufpd
(dst src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
va_eval_xmm va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
(va_if (permutation = 0 || permutation = 2)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1)))
(va_if (permutation = 0 || permutation = 2)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src1))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1)))
(va_if (permutation = 0 || permutation = 1)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src2))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src2)))
(va_if (permutation = 0 || permutation = 1)
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Mem128_lemma | val va_quick_Mem128_lemma
(h: heaplet_id)
(base: operand64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Mem128_lemma ())) | val va_quick_Mem128_lemma
(h: heaplet_id)
(base: operand64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Mem128_lemma ())) | let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 65,
"start_col": 0,
"start_line": 62
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.X64.Decls.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
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Mem128_lemma ()) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.heaplet_id",
"Vale.X64.Machine_s.operand64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Memory.buffer128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Mem128_lemma",
"Prims.Nil",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.InsVector.va_wp_Mem128_lemma",
"Vale.X64.InsVector.va_wpProof_Mem128_lemma",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Mem128_lemma
(h: heaplet_id)
(base: operand64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
: (va_quickCode unit (va_code_Mem128_lemma ())) =
| (va_QProc (va_code_Mem128_lemma ())
([])
(va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Pand | val va_quick_Pand (dst: va_operand_xmm) (src: va_operand_opr128)
: (va_quickCode unit (va_code_Pand dst src)) | val va_quick_Pand (dst: va_operand_xmm) (src: va_operand_opr128)
: (va_quickCode unit (va_code_Pand dst src)) | let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 205,
"start_col": 0,
"start_line": 202
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Pand dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Pand",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Pand",
"Vale.X64.InsVector.va_wpProof_Pand",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Pand (dst: va_operand_xmm) (src: va_operand_opr128)
: (va_quickCode unit (va_code_Pand dst src)) =
| (va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst src)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_VPaddd | val va_quick_VPaddd (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPaddd dst src1 src2)) | val va_quick_VPaddd (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPaddd dst src1 src2)) | let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 137,
"start_col": 0,
"start_line": 134
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_VPaddd dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_VPaddd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_VPaddd",
"Vale.X64.InsVector.va_wpProof_VPaddd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_VPaddd (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPaddd dst src1 src2)) =
| (va_QProc (va_code_VPaddd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPaddd dst src1 src2)
(va_wpProof_VPaddd dst src1 src2)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pshufb | val va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 564,
"start_col": 0,
"start_line": 558
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Pslld | val va_quick_Pslld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Pslld dst amt)) | val va_quick_Pslld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Pslld dst amt)) | let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 274,
"start_col": 0,
"start_line": 272
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Pslld 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_Pslld",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Pslld",
"Vale.X64.InsVector.va_wpProof_Pslld",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Pslld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Pslld dst amt)) =
| (va_QProc (va_code_Pslld dst amt)
([va_mod_xmm dst])
(va_wp_Pslld dst amt)
(va_wpProof_Pslld dst amt)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_PshufbStable | val va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 655,
"start_col": 0,
"start_line": 642
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.Def.Types_s.reverse_bytes_nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.reverse_bytes_nat32_quad32",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_VPxor | val va_quick_VPxor (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPxor dst src1 src2)) | val va_quick_VPxor (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPxor dst src1 src2)) | let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 241,
"start_col": 0,
"start_line": 238
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_VPxor dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_VPxor",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_VPxor",
"Vale.X64.InsVector.va_wpProof_VPxor",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_VPxor (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPxor dst src1 src2)) =
| (va_QProc (va_code_VPxor dst src1 src2)
([va_mod_xmm dst])
(va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Paddd | val va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) | val va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) | let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 100,
"start_col": 0,
"start_line": 97
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Paddd dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Paddd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Paddd",
"Vale.X64.InsVector.va_wpProof_Paddd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) =
| (va_QProc (va_code_Paddd dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Paddd dst src)
(va_wpProof_Paddd dst src)) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_pkey_len | val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)} | val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)} | let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 41,
"start_col": 0,
"start_line": 33
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | modBits: Lib.IntTypes.size_t -> eBits: Lib.IntTypes.size_t
-> res:
Prims.bool
{res <==> Hacl.Spec.RSAPSS.pkey_len_pre t (Lib.IntTypes.v modBits) (Lib.IntTypes.v eBits)} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.op_AmpAmp",
"Lib.IntTypes.op_Less_Dot",
"Lib.IntTypes.U32",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Less_Equals_Dot",
"Lib.IntTypes.op_Slash_Dot",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.int_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Prims.bool",
"Prims.l_iff",
"Hacl.Spec.RSAPSS.pkey_len_pre"
] | [] | false | false | false | false | false | let rsapss_check_pkey_len #t modBits eBits =
| if 1ul <. modBits && 0ul <. eBits
then
[@@ inline_let ]let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen
else false | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent | val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t | val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t | let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 127,
"start_col": 0,
"start_line": 123
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | bn_check_num_bits: Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t
-> Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.SEC",
"Lib.IntTypes.lognot",
"Hacl.Bignum.Definitions.limb",
"Hacl.Bignum.bn_is_zero_mask",
"Lib.IntTypes.int_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.IntTypes.mk_int",
"Hacl.Spec.Bignum.Definitions.blocks"
] | [] | false | false | false | false | false | let rsapss_check_exponent #t bn_check_num_bits eBits e =
| let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1 | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_PshufbDup | val va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 702,
"start_col": 0,
"start_line": 690
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.Def.Types_s.reverse_bytes_nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Pxor | val va_quick_Pxor (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst src)) | val va_quick_Pxor (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst src)) | let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 170,
"start_col": 0,
"start_line": 167
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Pxor dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Pxor",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Pxor",
"Vale.X64.InsVector.va_wpProof_Pxor",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Pxor (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst src)) =
| (va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst src)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Palignr4 | val va_quick_Palignr4 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr4 dst src)) | val va_quick_Palignr4 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr4 dst src)) | let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 347,
"start_col": 0,
"start_line": 344
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Palignr4 dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Palignr4",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Palignr4",
"Vale.X64.InsVector.va_wpProof_Palignr4",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Palignr4 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr4 dst src)) =
| (va_QProc (va_code_Palignr4 dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Psrld | val va_quick_Psrld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrld dst amt)) | val va_quick_Psrld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrld dst amt)) | let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 307,
"start_col": 0,
"start_line": 305
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> amt: Prims.int
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Psrld 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_Psrld",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Psrld",
"Vale.X64.InsVector.va_wpProof_Psrld",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Psrld (dst: va_operand_xmm) (amt: int) : (va_quickCode unit (va_code_Psrld dst amt)) =
| (va_QProc (va_code_Psrld dst amt)
([va_mod_xmm dst])
(va_wp_Psrld dst amt)
(va_wpProof_Psrld dst amt)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pshufd | val va_wp_Pshufd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pshufd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 800,
"start_col": 0,
"start_line": 787
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.select_word",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Types_s.twobits",
"Vale.Def.Types_s.byte_to_twobits",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pshufd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\
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_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits | val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t | val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t | let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 79,
"start_col": 0,
"start_line": 76
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Equals_Dot",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.ones",
"Lib.IntTypes.SEC",
"Hacl.Bignum.Definitions.limb",
"Prims.bool",
"Hacl.Bignum.bn_lt_pow2_mask",
"Lib.IntTypes.int_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks"
] | [] | false | false | false | false | false | let bn_check_num_bits #t bs b =
| [@@ inline_let ]let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pshufb64 | val va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 749,
"start_col": 0,
"start_line": 737
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.Def.Types_s.reverse_bytes_nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
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_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_VShufpd | val va_quick_VShufpd (dst src1 src2: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) | val va_quick_VShufpd (dst src1 src2: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) | let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 540,
"start_col": 0,
"start_line": 537
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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.QuickCode.va_quickCode Prims.unit
(Vale.X64.InsVector.va_code_VShufpd dst src1 src2 permutation) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_VShufpd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_VShufpd",
"Vale.X64.InsVector.va_wpProof_VShufpd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_VShufpd (dst src1 src2: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
| (va_QProc (va_code_VShufpd dst src1 src2 permutation)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation)
(va_wpProof_VShufpd dst src1 src2 permutation)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Pextrq | val va_wp_Pextrq
(dst: va_operand_dst_opr64)
(src: va_operand_xmm)
(index: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Pextrq
(dst: va_operand_dst_opr64)
(src: va_operand_xmm)
(index: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 886,
"start_col": 0,
"start_line": 880
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_is_dst_dst_opr64",
"Vale.X64.Decls.va_is_src_xmm",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.op_LessThan",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_dst_opr64",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_eval_dst_opr64",
"Vale.X64.Decls.va_if",
"Prims.op_Equality",
"Prims.int",
"Vale.Arch.Types.lo64",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_not",
"Vale.Arch.Types.hi64",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_dst_opr64"
] | [] | false | false | false | true | true | let va_wp_Pextrq
(dst: va_operand_dst_opr64)
(src: va_operand_xmm)
(index: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\
(forall (va_x_dst: va_value_dst_opr64).
let va_sM = va_upd_operand_dst_opr64 dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst ==
va_if (index = 0)
(fun _ -> Vale.Arch.Types.lo64 (va_eval_xmm va_sM src))
(fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Shufpd | val va_quick_Shufpd (dst src: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_Shufpd dst src permutation)) | val va_quick_Shufpd (dst src: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_Shufpd dst src permutation)) | let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 485,
"start_col": 0,
"start_line": 482
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
permutation: Vale.X64.Memory.nat8
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.X64.InsVector.va_code_Shufpd dst src permutation) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Memory.nat8",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Shufpd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Shufpd",
"Vale.X64.InsVector.va_wpProof_Shufpd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Shufpd (dst src: va_operand_xmm) (permutation: nat8)
: (va_quickCode unit (va_code_Shufpd dst src permutation)) =
| (va_QProc (va_code_Shufpd dst src permutation)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Shufpd dst src permutation)
(va_wpProof_Shufpd dst src permutation)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Palignr8 | val va_quick_Palignr8 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr8 dst src)) | val va_quick_Palignr8 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr8 dst src)) | let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 387,
"start_col": 0,
"start_line": 384
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Palignr8 dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Palignr8",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Palignr8",
"Vale.X64.InsVector.va_wpProof_Palignr8",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Palignr8 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Palignr8 dst src)) =
| (va_QProc (va_code_Palignr8 dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src)) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus | val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t | val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t | let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 104,
"start_col": 0,
"start_line": 98
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | bn_check_num_bits: Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t
-> Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.SEC",
"Hacl.Bignum.Definitions.limb",
"Hacl.Bignum.bn_gt_pow2_mask",
"Lib.IntTypes.op_Subtraction_Bang",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint",
"Hacl.Bignum.bn_is_odd",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.IntTypes.mk_int",
"Hacl.Spec.Bignum.Definitions.blocks"
] | [] | false | false | false | false | false | let rsapss_check_modulus #t bn_check_num_bits modBits n =
| let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_VPslldq4 | val va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 1076,
"start_col": 0,
"start_line": 1069
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\
(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 /\
va_eval_xmm va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==>
va_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_check_skey_len | val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)} | val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)} | let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 61,
"start_col": 0,
"start_line": 52
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | modBits: Lib.IntTypes.size_t -> eBits: Lib.IntTypes.size_t -> dBits: Lib.IntTypes.size_t
-> res:
Prims.bool
{ res <==>
Hacl.Spec.RSAPSS.skey_len_pre t
(Lib.IntTypes.v modBits)
(Lib.IntTypes.v eBits)
(Lib.IntTypes.v dBits) } | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.op_AmpAmp",
"Hacl.Impl.RSAPSS.Keys.rsapss_check_pkey_len",
"Lib.IntTypes.op_Less_Dot",
"Lib.IntTypes.U32",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Less_Equals_Dot",
"Lib.IntTypes.op_Slash_Dot",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Subtraction_Bang",
"Lib.IntTypes.int_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Prims.bool",
"Prims.l_iff",
"Hacl.Spec.RSAPSS.skey_len_pre"
] | [] | false | false | false | false | false | let rsapss_check_skey_len #t modBits eBits dBits =
| if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits
then
[@@ inline_let ]let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits && 2ul *! nLen <=. 0xfffffffful -! eLen -! dLen
else false | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_VPshufb | val va_quick_VPshufb (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPshufb dst src1 src2)) | val va_quick_VPshufb (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPshufb dst src1 src2)) | let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 617,
"start_col": 0,
"start_line": 614
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_VPshufb dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_VPshufb",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_VPshufb",
"Vale.X64.InsVector.va_wpProof_VPshufb",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_VPshufb (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPshufb dst src1 src2)) =
| (va_QProc (va_code_VPshufb dst src1 src2)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPshufb dst src1 src2)
(va_wpProof_VPshufb dst src1 src2)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Vpslldq8 | val va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 1112,
"start_col": 0,
"start_line": 1106
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\
(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 /\
va_eval_xmm va_sM dst ==
Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32
0
0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_VPalignr8 | val va_quick_VPalignr8 (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPalignr8 dst src1 src2)) | val va_quick_VPalignr8 (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPalignr8 dst src1 src2)) | let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 432,
"start_col": 0,
"start_line": 429
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_VPalignr8 dst src1 src2) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_VPalignr8",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_VPalignr8",
"Vale.X64.InsVector.va_wpProof_VPalignr8",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_VPalignr8 (dst src1 src2: va_operand_xmm)
: (va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
| (va_QProc (va_code_VPalignr8 dst src1 src2)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPalignr8 dst src1 src2)
(va_wpProof_VPalignr8 dst src1 src2)) | false |
Steel.Semantics.Instantiate.fsti | Steel.Semantics.Instantiate.state0 | val state0 (uses: inames) : S.st0 | val state0 (uses: inames) : S.st0 | let state0 (uses:inames) : S.st0 =
{
S.mem = mem;
S.core = core_mem;
S.full_mem_pred = full_mem_pred;
S.locks_preorder = mem_evolves;
S.hprop = slprop;
S.locks_invariant = locks_invariant uses;
S.disjoint = disjoint;
S.join = join;
S.interp = interp;
S.emp = emp;
S.star = star;
S.equals = equiv
} | {
"file_name": "lib/steel/Steel.Semantics.Instantiate.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 40,
"start_col": 0,
"start_line": 22
} | (*
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.Semantics.Instantiate
module S = Steel.Semantics.Hoare.MST
open Steel.Memory | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Semantics.Instantiate.fsti"
} | [
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Steel.Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | uses: Steel.Memory.inames -> Steel.Semantics.Hoare.MST.st0 | Prims.Tot | [
"total"
] | [] | [
"Steel.Memory.inames",
"Steel.Semantics.Hoare.MST.Mkst0",
"Steel.Memory.mem",
"Steel.Memory.core_mem",
"Steel.Memory.full_mem_pred",
"Steel.Memory.mem_evolves",
"Steel.Memory.slprop",
"Steel.Memory.locks_invariant",
"Steel.Memory.disjoint",
"Steel.Memory.join",
"Steel.Memory.interp",
"Steel.Memory.emp",
"Steel.Memory.star",
"Steel.Memory.equiv",
"Steel.Semantics.Hoare.MST.st0"
] | [] | false | false | false | true | false | let state0 (uses: inames) : S.st0 =
| {
S.mem = mem;
S.core = core_mem;
S.full_mem_pred = full_mem_pred;
S.locks_preorder = mem_evolves;
S.hprop = slprop;
S.locks_invariant = locks_invariant uses;
S.disjoint = disjoint;
S.join = join;
S.interp = interp;
S.emp = emp;
S.star = star;
S.equals = equiv
} | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Pshufb | val va_quick_Pshufb (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb dst src)) | val va_quick_Pshufb (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb dst src)) | let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 576,
"start_col": 0,
"start_line": 573
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Pshufb dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Pshufb",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Pshufb",
"Vale.X64.InsVector.va_wpProof_Pshufb",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Pshufb (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb dst src)) =
| (va_QProc (va_code_Pshufb dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Mov128 | val va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == va_eval_xmm va_s0 src ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 1180,
"start_col": 0,
"start_line": 1176
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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))))
[@ va_qattr]
let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (())))
val va_wpProof_Vpslldq8 : 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_Vpslldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpslldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpslldq8 dst src)) =
(va_QProc (va_code_Vpslldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpslldq8 dst src)
(va_wpProof_Vpslldq8 dst src))
//--
//-- Vpsrldq8
val va_code_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpsrldq8 : 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_Vpsrldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) 0 0 /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ 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)) 0 0 ==> va_k va_sM (())))
val va_wpProof_Vpsrldq8 : 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_Vpsrldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpsrldq8 dst src)) =
(va_QProc (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpsrldq8 dst src)
(va_wpProof_Vpsrldq8 dst src))
//--
//-- Mov128
val va_code_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Mov128 : 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_Mov128 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 == 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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.X64.Decls.quad32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ va_eval_xmm va_sM dst == va_eval_xmm va_s0 src ==> va_k va_sM (()))) | false |
Steel.Semantics.Instantiate.fsti | Steel.Semantics.Instantiate.state | val state:S.st | val state:S.st | let state : S.st = state_uses Set.empty | {
"file_name": "lib/steel/Steel.Semantics.Instantiate.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 39,
"end_line": 47,
"start_col": 0,
"start_line": 47
} | (*
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.Semantics.Instantiate
module S = Steel.Semantics.Hoare.MST
open Steel.Memory
let state0 (uses:inames) : S.st0 =
{
S.mem = mem;
S.core = core_mem;
S.full_mem_pred = full_mem_pred;
S.locks_preorder = mem_evolves;
S.hprop = slprop;
S.locks_invariant = locks_invariant uses;
S.disjoint = disjoint;
S.join = join;
S.interp = interp;
S.emp = emp;
S.star = star;
S.equals = equiv
}
val state_obeys_st_laws (uses:inames)
: Lemma (S.st_laws (state0 uses))
let state_uses (uses:inames) : S.st = state_obeys_st_laws uses; state0 uses | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Semantics.Instantiate.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Semantics.Hoare.MST",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Steel.Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": 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 | Steel.Semantics.Hoare.MST.st | Prims.Tot | [
"total"
] | [] | [
"Steel.Semantics.Instantiate.state_uses",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty"
] | [] | false | false | false | true | false | let state:S.st =
| state_uses Set.empty | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.new_rsapss_load_skey_st | val new_rsapss_load_skey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | let new_rsapss_load_skey_st (t:limb_t) (ke:BE.exp t) (modBits:size_t) =
r:HS.rid
-> eBits:size_t
-> dBits:size_t
-> nb:lbuffer uint8 (blocks0 modBits 8ul)
-> eb:lbuffer uint8 (blocks0 eBits 8ul)
-> db:lbuffer uint8 (blocks0 dBits 8ul) ->
ST (B.buffer (limb t))
(requires fun h ->
blocks0 modBits (size (bits t)) == ke.BE.bn.BN.len /\
live h nb /\ live h eb /\ live h db /\
ST.is_eternal_region r)
(ensures fun h0 skey h1 -> B.(modifies loc_none h0 h1) /\
not (B.g_is_null skey) ==> (
LS.skey_len_pre t (v modBits) (v eBits) (v dBits) /\
B.(fresh_loc (loc_buffer skey) h0 h1) /\
B.freeable skey /\
B.(loc_includes (loc_region_only false r) (loc_buffer skey)) /\
(let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let skeyLen = nLen +! nLen +! eLen +! dLen in
B.len skey == skeyLen /\
(let skey = skey <: lbignum t skeyLen in
LS.rsapss_load_skey_post (v modBits) (v eBits) (v dBits)
(as_seq h0 nb) (as_seq h0 eb) (as_seq h0 db) (as_seq h1 skey))))) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 393,
"start_col": 0,
"start_line": 366
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits
[@CInline]
let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64
[@CInline]
let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint64: rsapss_checks U64
let mk_runtime_rsapss_checks_uint64 = {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64;
}
inline_for_extraction noextract
let mk_runtime_rsapss_checks (#t:limb_t) : rsapss_checks t =
match t with
| U32 -> mk_runtime_rsapss_checks_uint32
| U64 -> mk_runtime_rsapss_checks_uint64
//pkey = [n; r2; e]
inline_for_extraction noextract
let rsapss_load_pkey_st (t:limb_t) (ke:BE.exp t) (modBits:size_t) =
eBits:size_t{LS.pkey_len_pre t (v modBits) (v eBits)}
-> nb:lbuffer uint8 (blocks modBits 8ul)
-> eb:lbuffer uint8 (blocks eBits 8ul)
-> pkey:lbignum t (2ul *! blocks modBits (size (bits t)) +! blocks eBits (size (bits t))) ->
Stack bool
(requires fun h ->
blocks modBits (size (bits t)) == ke.BE.bn.BN.len /\
live h nb /\ live h eb /\ live h pkey /\
disjoint pkey nb /\ disjoint pkey eb)
(ensures fun h0 b h1 -> modifies (loc pkey) h0 h1 /\
(b, as_seq h1 pkey) == LS.rsapss_load_pkey (v modBits) (v eBits) (as_seq h0 nb) (as_seq h0 eb))
inline_for_extraction noextract
val rsapss_load_pkey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
rsapss_load_pkey_st t ke modBits
let rsapss_load_pkey #t ke modBits kc eBits nb eb pkey =
let h0 = ST.get () in
[@inline_let] let bits = size (bits t) in
[@inline_let] let numb = size (numbytes t) in
let nbLen = blocks modBits 8ul in
let ebLen = blocks eBits 8ul in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
assert (v ((modBits -! 1ul) /. bits) < v nLen);
LS.blocks_bits_lemma t (v modBits);
assert (v (blocks nbLen numb) == v nLen);
LS.blocks_bits_lemma t (v eBits);
assert (v (blocks ebLen numb) == v eLen);
let n = sub pkey 0ul nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen +! nLen) eLen in
BN.bn_from_bytes_be nbLen nb n;
ke.BE.precompr2 (modBits -! 1ul) n r2;
BN.bn_from_bytes_be ebLen eb e;
let h1 = ST.get () in
LSeq.lemma_concat3 (v nLen) (as_seq h1 n)
(v nLen) (as_seq h1 r2) (v eLen) (as_seq h1 e) (as_seq h1 pkey);
let m0 = kc.check_modulus modBits n in
let m1 = kc.check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb #t m
#set-options "--z3rlimit 300"
//skey = [pkey; d]
inline_for_extraction noextract
let rsapss_load_skey_st (t:limb_t) (ke:BE.exp t) (modBits:size_t) =
eBits:size_t
-> dBits:size_t{LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
-> nb:lbuffer uint8 (blocks modBits 8ul)
-> eb:lbuffer uint8 (blocks eBits 8ul)
-> db:lbuffer uint8 (blocks dBits 8ul)
-> skey:lbignum t (2ul *! blocks modBits (size (bits t)) +! blocks eBits (size (bits t)) +! blocks dBits (size (bits t))) ->
Stack bool
(requires fun h ->
blocks modBits (size (bits t)) == ke.BE.bn.BN.len /\
live h nb /\ live h eb /\ live h db /\ live h skey /\
disjoint skey nb /\ disjoint skey eb /\ disjoint skey db)
(ensures fun h0 b h1 -> modifies (loc skey) h0 h1 /\
(b, as_seq h1 skey) == LS.rsapss_load_skey (v modBits) (v eBits) (v dBits)
(as_seq h0 nb) (as_seq h0 eb) (as_seq h0 db))
inline_for_extraction noextract
val rsapss_load_skey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t
-> rsapss_load_pkey:rsapss_load_pkey_st t ke modBits ->
rsapss_load_skey_st t ke modBits
let rsapss_load_skey #t ke modBits kc rsapss_load_pkey eBits dBits nb eb db skey =
let h0 = ST.get () in
[@inline_let] let bits = size (bits t) in
[@inline_let] let numb = size (numbytes t) in
let nbLen = blocks modBits 8ul in
let ebLen = blocks eBits 8ul in
let dbLen = blocks dBits 8ul in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen +! nLen +! eLen in
let skeyLen = pkeyLen +! eLen in
LS.blocks_bits_lemma t (v dBits);
assert (v (blocks dbLen numb) == v dLen);
let pkey = sub skey 0ul pkeyLen in
let d = sub skey pkeyLen dLen in
let b = rsapss_load_pkey eBits nb eb pkey in
BN.bn_from_bytes_be dbLen db d;
let h1 = ST.get () in
LSeq.lemma_concat2 (v pkeyLen) (as_seq h1 pkey) (v dLen) (as_seq h1 d) (as_seq h1 skey);
let m1 = kc.check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m1 in
b1
inline_for_extraction noextract
let new_rsapss_load_pkey_st (t:limb_t) (ke:BE.exp t) (modBits:size_t) =
r:HS.rid
-> eBits:size_t
-> nb:lbuffer uint8 (blocks0 modBits 8ul)
-> eb:lbuffer uint8 (blocks0 eBits 8ul) ->
ST (B.buffer (limb t))
(requires fun h ->
blocks0 modBits (size (bits t)) == ke.BE.bn.BN.len /\
live h nb /\ live h eb /\ ST.is_eternal_region r)
(ensures fun h0 pkey h1 -> B.(modifies loc_none h0 h1) /\
not (B.g_is_null pkey) ==> (
LS.pkey_len_pre t (v modBits) (v eBits) /\
B.(fresh_loc (loc_buffer pkey) h0 h1) /\
B.freeable pkey /\
B.(loc_includes (loc_region_only false r) (loc_buffer pkey)) /\
(let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let pkeyLen = nLen +! nLen +! eLen in
B.len pkey == pkeyLen /\
(let pkey = pkey <: lbignum t pkeyLen in
LS.rsapss_load_pkey_post (v modBits) (v eBits)
(as_seq h0 nb) (as_seq h0 eb) (as_seq h1 pkey)))))
inline_for_extraction noextract
val new_rsapss_load_pkey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
new_rsapss_load_pkey_st t ke modBits
let new_rsapss_load_pkey #t ke modBits kc r eBits nb eb =
[@inline_let] let bits = size (bits t) in
if not (rsapss_check_pkey_len #t modBits eBits) then
B.null
else
let h0 = ST.get () in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let pkeyLen = nLen +! nLen +! eLen in
let pkey = LowStar.Monotonic.Buffer.mmalloc_partial r (uint #t 0) pkeyLen in
if B.is_null pkey then
pkey
else
let h1 = ST.get () in
B.(modifies_only_not_unused_in loc_none h0 h1);
assert (B.len pkey == pkeyLen);
let pkey: Lib.Buffer.buffer (limb t) = pkey in
assert (B.length pkey == FStar.UInt32.v pkeyLen);
let pkey: lbignum t pkeyLen = pkey in
let b = rsapss_load_pkey ke modBits kc eBits nb eb pkey in
let h2 = ST.get () in
B.(modifies_only_not_unused_in loc_none h0 h2);
LS.rsapss_load_pkey_lemma #t (v modBits) (v eBits) (as_seq h0 nb) (as_seq h0 eb);
if b then pkey else begin
B.free (pkey <: buffer (limb t));
B.null end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"FStar.Monotonic.HyperHeap.rid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Definitions.blocks0",
"FStar.UInt32.__uint_to_t",
"LowStar.Buffer.buffer",
"Hacl.Bignum.Definitions.limb",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"FStar.Mul.op_Star",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Prims.op_LessThan",
"Hacl.Bignum.__proj__Mkbn__item__len",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"FStar.HyperStack.ST.is_eternal_region",
"Prims.l_imp",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Buffer.trivial_preorder",
"Hacl.Spec.RSAPSS.skey_len_pre",
"LowStar.Monotonic.Buffer.fresh_loc",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Monotonic.Buffer.freeable",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.loc_region_only",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.len",
"Hacl.Spec.RSAPSS.rsapss_load_skey_post",
"Lib.Buffer.as_seq",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Bang",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Bignum.Definitions.blocks"
] | [] | false | false | false | false | true | let new_rsapss_load_skey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) =
|
r: HS.rid ->
eBits: size_t ->
dBits: size_t ->
nb: lbuffer uint8 (blocks0 modBits 8ul) ->
eb: lbuffer uint8 (blocks0 eBits 8ul) ->
db: lbuffer uint8 (blocks0 dBits 8ul)
-> ST (B.buffer (limb t))
(requires
fun h ->
blocks0 modBits (size (bits t)) == ke.BE.bn.BN.len /\ live h nb /\ live h eb /\ live h db /\
ST.is_eternal_region r)
(ensures
fun h0 skey h1 ->
B.(modifies loc_none h0 h1) /\ not (B.g_is_null skey) ==>
(LS.skey_len_pre t (v modBits) (v eBits) (v dBits) /\
B.(fresh_loc (loc_buffer skey) h0 h1) /\ B.freeable skey /\
B.(loc_includes (loc_region_only false r) (loc_buffer skey)) /\
(let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let skeyLen = nLen +! nLen +! eLen +! dLen in
B.len skey == skeyLen /\
(let skey = skey <: lbignum t skeyLen in
LS.rsapss_load_skey_post (v modBits)
(v eBits)
(v dBits)
(as_seq h0 nb)
(as_seq h0 eb)
(as_seq h0 db)
(as_seq h1 skey))))) | false |
|
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_quick_Pshufb64 | val va_quick_Pshufb64 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb64 dst src)) | val va_quick_Pshufb64 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb64 dst src)) | let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src)) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 761,
"start_col": 0,
"start_line": 758
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.InsVector.va_code_Pshufb64 dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.InsVector.va_code_Pshufb64",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.X64.InsVector.va_wp_Pshufb64",
"Vale.X64.InsVector.va_wpProof_Pshufb64",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Pshufb64 (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Pshufb64 dst src)) =
| (va_QProc (va_code_Pshufb64 dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src)) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Vpsrldq8 | val va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ 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)) 0 0 ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 98,
"end_line": 1148,
"start_col": 0,
"start_line": 1142
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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))))
[@ va_qattr]
let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (())))
val va_wpProof_Vpslldq8 : 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_Vpslldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpslldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpslldq8 dst src)) =
(va_QProc (va_code_Vpslldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpslldq8 dst src)
(va_wpProof_Vpslldq8 dst src))
//--
//-- Vpsrldq8
val va_code_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpsrldq8 : 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_Vpsrldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) 0 0 /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\
(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 /\
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))
0
0 ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_Load128_buffer | val va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_xmm)
(src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_xmm)
(src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_xmm) (src:va_operand_reg_opr64)
(offset:int) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (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
/\ va_eval_xmm va_sM dst == Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==>
va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 1230,
"start_col": 0,
"start_line": 1218
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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))))
[@ va_qattr]
let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (())))
val va_wpProof_Vpslldq8 : 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_Vpslldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpslldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpslldq8 dst src)) =
(va_QProc (va_code_Vpslldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpslldq8 dst src)
(va_wpProof_Vpslldq8 dst src))
//--
//-- Vpsrldq8
val va_code_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpsrldq8 : 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_Vpsrldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) 0 0 /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ 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)) 0 0 ==> va_k va_sM (())))
val va_wpProof_Vpsrldq8 : 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_Vpsrldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpsrldq8 dst src)) =
(va_QProc (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpsrldq8 dst src)
(va_wpProof_Vpsrldq8 dst src))
//--
//-- Mov128
val va_code_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Mov128 : 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_Mov128 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 == 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))))
[@ va_qattr]
let va_wp_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == va_eval_xmm va_s0 src ==> va_k va_sM (())))
val va_wpProof_Mov128 : 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_Mov128 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mov128 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Mov128
dst src)) =
(va_QProc (va_code_Mov128 dst src) ([va_mod_xmm dst]) (va_wp_Mov128 dst src) (va_wpProof_Mov128
dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm -> src:va_operand_reg_opr64
-> offset:int -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_xmm -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> b:buffer128 ->
index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst src offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(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.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.X64.Decls.va_operand_heaplet ->
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_reg_opr64 ->
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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_heaplet",
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_reg_opr64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_src_heaplet",
"Vale.X64.Decls.va_is_dst_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_is_src_reg_opr64",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Vale.X64.Decls.valid_src_addr",
"Vale.X64.Memory.vuint128",
"Vale.X64.Decls.va_eval_heaplet",
"Vale.X64.Memory.valid_layout_buffer",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Prims.op_Addition",
"Vale.X64.Decls.va_eval_reg_opr64",
"Vale.X64.Memory.buffer_addr",
"Prims.op_Multiply",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Prims.l_imp",
"Vale.X64.Decls.quad32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.X64.Decls.buffer128_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_xmm)
(src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\
Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.X64.Memory.valid_layout_buffer #Vale.X64.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.X64.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr64 va_s0 src + offset ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index /\
(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 /\
va_eval_xmm va_sM dst == Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==>
va_k va_sM (()))) | false |
Hacl.Impl.RSAPSS.Keys.fst | Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey_st | val rsapss_load_pkey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | let rsapss_load_pkey_st (t:limb_t) (ke:BE.exp t) (modBits:size_t) =
eBits:size_t{LS.pkey_len_pre t (v modBits) (v eBits)}
-> nb:lbuffer uint8 (blocks modBits 8ul)
-> eb:lbuffer uint8 (blocks eBits 8ul)
-> pkey:lbignum t (2ul *! blocks modBits (size (bits t)) +! blocks eBits (size (bits t))) ->
Stack bool
(requires fun h ->
blocks modBits (size (bits t)) == ke.BE.bn.BN.len /\
live h nb /\ live h eb /\ live h pkey /\
disjoint pkey nb /\ disjoint pkey eb)
(ensures fun h0 b h1 -> modifies (loc pkey) h0 h1 /\
(b, as_seq h1 pkey) == LS.rsapss_load_pkey (v modBits) (v eBits) (as_seq h0 nb) (as_seq h0 eb)) | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 98,
"end_line": 195,
"start_col": 0,
"start_line": 184
} | module Hacl.Impl.RSAPSS.Keys
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module LSeq = Lib.Sequence
module LS = Hacl.Spec.RSAPSS
module BM = Hacl.Bignum.Montgomery
module BN = Hacl.Bignum
module BB = Hacl.Spec.Bignum.Base
module BE = Hacl.Bignum.Exponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val rsapss_check_pkey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t ->
res:bool{res <==> LS.pkey_len_pre t (v modBits) (v eBits)}
let rsapss_check_pkey_len #t modBits eBits =
if 1ul <. modBits && 0ul <. eBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
nLen <=. 0xfffffffful /. (2ul *! bits) && eLen <=. 0xfffffffful /. bits &&
nLen +! nLen <=. 0xfffffffful -. eLen end
else false
inline_for_extraction noextract
val rsapss_check_skey_len:
#t:limb_t
-> modBits:size_t
-> eBits:size_t
-> dBits:size_t ->
res:bool{res <==> LS.skey_len_pre t (v modBits) (v eBits) (v dBits)}
let rsapss_check_skey_len #t modBits eBits dBits =
if rsapss_check_pkey_len #t modBits eBits && 0ul <. dBits then begin
[@inline_let] let bits = size (bits t) in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
dLen <=. 0xfffffffful /. bits &&
2ul *! nLen <=. 0xfffffffful -! eLen -! dLen end
else false
inline_for_extraction noextract
let bn_check_num_bits_st (t:limb_t) =
bs:size_t{0 < v bs /\ bits t * v (blocks bs (size (bits t))) <= max_size_t}
-> b:lbignum t (blocks bs (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h b)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.bn_check_num_bits (v bs) (as_seq h0 b))
inline_for_extraction noextract
val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b =
[@inline_let] let bits = size (bits t) in
let bLen = blocks bs bits in
if bs =. bits *! bLen then ones t SEC else BN.bn_lt_pow2_mask bLen b bs
inline_for_extraction noextract
let rsapss_check_modulus_st (t:limb_t) =
modBits:size_t{0 < v modBits /\ bits t * v (blocks modBits (size (bits t))) <= max_size_t}
-> n:lbignum t (blocks modBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h n)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_modulus (v modBits) (as_seq h0 n))
inline_for_extraction noextract
val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t
let rsapss_check_modulus #t bn_check_num_bits modBits n =
let nLen = blocks modBits (size (bits t)) in
let bits0 = BN.bn_is_odd nLen n in
let m0 = uint #t 0 -. bits0 in
let m1 = BN.bn_gt_pow2_mask nLen n (modBits -! 1ul) in
let m2 = bn_check_num_bits modBits n in
m0 &. (m1 &. m2)
inline_for_extraction noextract
let rsapss_check_exponent_st (t:limb_t) =
eBits:size_t{0 < v eBits /\ bits t * v (blocks eBits (size (bits t))) <= max_size_t}
-> e:lbignum t (blocks eBits (size (bits t))) ->
Stack (limb t)
(requires fun h -> live h e)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == LS.rsapss_check_exponent (v eBits) (as_seq h0 e))
inline_for_extraction noextract
val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t
let rsapss_check_exponent #t bn_check_num_bits eBits e =
let eLen = blocks eBits (size (bits t)) in
let m0 = BN.bn_is_zero_mask eLen e in
let m1 = bn_check_num_bits eBits e in
(lognot m0) &. m1
inline_for_extraction noextract
class rsapss_checks (t:limb_t) = {
check_num_bits: bn_check_num_bits_st t;
check_modulus: rsapss_check_modulus_st t;
check_exponent: rsapss_check_exponent_st t;
}
[@CInline]
let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits
[@CInline]
let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32
[@CInline]
let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
}
[@CInline]
let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits
[@CInline]
let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64
[@CInline]
let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64
inline_for_extraction noextract
val mk_runtime_rsapss_checks_uint64: rsapss_checks U64
let mk_runtime_rsapss_checks_uint64 = {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64;
}
inline_for_extraction noextract
let mk_runtime_rsapss_checks (#t:limb_t) : rsapss_checks t =
match t with
| U32 -> mk_runtime_rsapss_checks_uint32
| U64 -> mk_runtime_rsapss_checks_uint64
//pkey = [n; r2; e] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.RSAPSS.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Exponentiation.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.RSAPSS.Keys.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.RSAPSS",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.RSAPSS",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Definitions.blocks",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.size",
"Lib.IntTypes.bits",
"Prims.bool",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.int",
"Lib.IntTypes.range",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Prims.op_LessThan",
"Hacl.Bignum.__proj__Mkbn__item__len",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__bn",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Buffer.as_seq",
"Hacl.Spec.RSAPSS.rsapss_load_pkey"
] | [] | false | false | false | false | true | let rsapss_load_pkey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) =
|
eBits: size_t{LS.pkey_len_pre t (v modBits) (v eBits)} ->
nb: lbuffer uint8 (blocks modBits 8ul) ->
eb: lbuffer uint8 (blocks eBits 8ul) ->
pkey: lbignum t (2ul *! blocks modBits (size (bits t)) +! blocks eBits (size (bits t)))
-> Stack bool
(requires
fun h ->
blocks modBits (size (bits t)) == ke.BE.bn.BN.len /\ live h nb /\ live h eb /\ live h pkey /\
disjoint pkey nb /\ disjoint pkey eb)
(ensures
fun h0 b h1 ->
modifies (loc pkey) h0 h1 /\
(b, as_seq h1 pkey) ==
LS.rsapss_load_pkey (v modBits) (v eBits) (as_seq h0 nb) (as_seq h0 eb)) | false |
|
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_LoadBe64_buffer128 | val va_wp_LoadBe64_buffer128
(h: va_operand_heaplet)
(dst src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(upper: bool)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_LoadBe64_buffer128
(h: va_operand_heaplet)
(dst src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(upper: bool)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_LoadBe64_buffer128 (h:va_operand_heaplet) (dst:va_operand_reg_opr64)
(src:va_operand_reg_opr64) (offset:int) (t:taint) (upper:bool) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ movbe_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index + va_if upper
(fun _ -> 8) (fun _ -> 0) /\ (forall (va_x_dst:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_reg_opr64 va_sM dst
== Vale.Def.Types_s.reverse_bytes_nat64 (va_if upper (fun _ -> Vale.Arch.Types.hi64
(Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h))) (fun _ ->
Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h)))) ==>
va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 1288,
"start_col": 0,
"start_line": 1273
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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))))
[@ va_qattr]
let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (())))
val va_wpProof_Vpslldq8 : 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_Vpslldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpslldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpslldq8 dst src)) =
(va_QProc (va_code_Vpslldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpslldq8 dst src)
(va_wpProof_Vpslldq8 dst src))
//--
//-- Vpsrldq8
val va_code_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpsrldq8 : 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_Vpsrldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) 0 0 /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ 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)) 0 0 ==> va_k va_sM (())))
val va_wpProof_Vpsrldq8 : 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_Vpsrldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpsrldq8 dst src)) =
(va_QProc (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpsrldq8 dst src)
(va_wpProof_Vpsrldq8 dst src))
//--
//-- Mov128
val va_code_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Mov128 : 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_Mov128 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 == 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))))
[@ va_qattr]
let va_wp_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == va_eval_xmm va_s0 src ==> va_k va_sM (())))
val va_wpProof_Mov128 : 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_Mov128 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mov128 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Mov128
dst src)) =
(va_QProc (va_code_Mov128 dst src) ([va_mod_xmm dst]) (va_wp_Mov128 dst src) (va_wpProof_Mov128
dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm -> src:va_operand_reg_opr64
-> offset:int -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_xmm -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> b:buffer128 ->
index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst src offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(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.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_xmm) (src:va_operand_reg_opr64)
(offset:int) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (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
/\ va_eval_xmm va_sM dst == Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==>
va_k va_sM (())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm ->
src:va_operand_reg_opr64 -> 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_Load128_buffer h dst src offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst src offset t)
([va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_xmm) (src:va_operand_reg_opr64)
(offset:int) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit (va_code_Load128_buffer h
dst src offset t)) =
(va_QProc (va_code_Load128_buffer h dst src offset t) ([va_mod_xmm dst]) (va_wp_Load128_buffer h
dst src offset t b index) (va_wpProof_Load128_buffer h dst src offset t b index))
//--
//-- LoadBe64_buffer128
val va_code_LoadBe64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_code
val va_codegen_success_LoadBe64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_pbool
val va_lemma_LoadBe64_buffer128 : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_reg_opr64 -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_LoadBe64_buffer128 h dst src offset t upper) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ movbe_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index + (if upper then
8 else 0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr64 va_sM dst == Vale.Def.Types_s.reverse_bytes_nat64 (if upper then
Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) else
Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h))) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 dst va_sM va_s0)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
h: Vale.X64.Decls.va_operand_heaplet ->
dst: Vale.X64.Decls.va_operand_reg_opr64 ->
src: Vale.X64.Decls.va_operand_reg_opr64 ->
offset: Prims.int ->
t: Vale.Arch.HeapTypes_s.taint ->
upper: Prims.bool ->
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)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_heaplet",
"Vale.X64.Decls.va_operand_reg_opr64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Prims.bool",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_src_heaplet",
"Vale.X64.Decls.va_is_dst_reg_opr64",
"Prims.b2t",
"Vale.X64.Decls.va_is_src_reg_opr64",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.movbe_enabled",
"Vale.X64.Decls.valid_src_addr",
"Vale.X64.Memory.vuint128",
"Vale.X64.Decls.va_eval_heaplet",
"Vale.X64.Memory.valid_layout_buffer",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Memory.valid_taint_buf128",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Prims.eq2",
"Prims.op_Addition",
"Vale.X64.Decls.va_eval_reg_opr64",
"Vale.X64.Memory.buffer_addr",
"Prims.op_Multiply",
"Vale.X64.Decls.va_if",
"Prims.l_not",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_reg_opr64",
"Prims.l_imp",
"Vale.Def.Types_s.nat64",
"Vale.Def.Types_s.reverse_bytes_nat64",
"Vale.Def.Words_s.nat64",
"Vale.Arch.Types.hi64",
"Vale.X64.Decls.buffer128_read",
"Vale.Arch.Types.lo64",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_operand_reg_opr64"
] | [] | false | false | false | true | true | let va_wp_LoadBe64_buffer128
(h: va_operand_heaplet)
(dst src: va_operand_reg_opr64)
(offset: int)
(t: taint)
(upper: bool)
(b: buffer128)
(index: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_src_heaplet h va_s0 /\ va_is_dst_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ movbe_enabled /\
Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128 (va_eval_heaplet va_s0 h) b index /\
Vale.X64.Memory.valid_layout_buffer #Vale.X64.Memory.vuint128
b
(va_get_mem_layout va_s0)
(va_eval_heaplet va_s0 h)
false /\
Vale.X64.Memory.valid_taint_buf128 b
(va_eval_heaplet va_s0 h)
((va_get_mem_layout va_s0).vl_taint)
t /\
va_eval_reg_opr64 va_s0 src + offset ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) +
16
`op_Multiply`
index +
va_if upper (fun _ -> 8) (fun _ -> 0) /\
(forall (va_x_dst: va_value_reg_opr64).
let va_sM = va_upd_operand_reg_opr64 dst va_x_dst va_s0 in
va_get_ok va_sM /\
va_eval_reg_opr64 va_sM dst ==
Vale.Def.Types_s.reverse_bytes_nat64 (va_if upper
(fun _ ->
Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read b
index
(va_eval_heaplet va_sM h)))
(fun _ ->
Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read b
index
(va_eval_heaplet va_sM h)))) ==>
va_k va_sM (()))) | false |
Vale.X64.InsVector.fsti | Vale.X64.InsVector.va_wp_ZeroXmm | val va_wp_ZeroXmm (dst: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_ZeroXmm (dst: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_ZeroXmm (dst:va_operand_xmm) (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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 0 0 0 0 ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 1436,
"start_col": 0,
"start_line": 1432
} | module Vale.X64.InsVector
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.HeapTypes_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.CPU_Features_s
let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h
//-- Mem128_lemma
val va_code_Mem128_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Mem128_lemma : va_dummy:unit -> Tot va_pbool
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)))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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) /\ (let va_sM = va_s0 in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mem128_lemma (h:heaplet_id) (base:operand64) (offset:int) (t:taint) (b:buffer128)
(index:int) : (va_quickCode unit (va_code_Mem128_lemma ())) =
(va_QProc (va_code_Mem128_lemma ()) ([]) (va_wp_Mem128_lemma h base offset t b index)
(va_wpProof_Mem128_lemma h base offset t b index))
//--
//-- Paddd
val va_code_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Paddd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Paddd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Paddd
dst src)) =
(va_QProc (va_code_Paddd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Paddd dst src)
(va_wpProof_Paddd dst src))
//--
//-- VPaddd
val va_code_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot va_code
val va_codegen_success_VPaddd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPaddd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPaddd dst src1 src2)) =
(va_QProc (va_code_VPaddd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPaddd dst src1
src2) (va_wpProof_VPaddd dst src1 src2))
//--
//-- Pxor
val va_code_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pxor : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pxor (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pxor dst
src)) =
(va_QProc (va_code_Pxor dst src) ([va_mod_xmm dst]) (va_wp_Pxor dst src) (va_wpProof_Pxor dst
src))
//--
//-- Pand
val va_code_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_code
val va_codegen_success_Pand : dst:va_operand_xmm -> src:va_operand_opr128 -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pand (dst:va_operand_xmm) (src:va_operand_opr128) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr128 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pand (dst:va_operand_xmm) (src:va_operand_opr128) : (va_quickCode unit (va_code_Pand
dst src)) =
(va_QProc (va_code_Pand dst src) ([va_mod_xmm dst]) (va_wp_Pand dst src) (va_wpProof_Pand dst
src))
//--
//-- VPxor
val va_code_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPxor : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128
-> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (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 /\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPxor (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPxor dst src1 src2)) =
(va_QProc (va_code_VPxor dst src1 src2) ([va_mod_xmm dst]) (va_wp_VPxor dst src1 src2)
(va_wpProof_VPxor dst src1 src2))
//--
//-- Pslld
val va_code_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Pslld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Pslld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pslld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Pslld dst amt)) =
(va_QProc (va_code_Pslld dst amt) ([va_mod_xmm dst]) (va_wp_Pslld dst amt) (va_wpProof_Pslld dst
amt))
//--
//-- Psrld
val va_code_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_code
val va_codegen_success_Psrld : dst:va_operand_xmm -> amt:int -> Tot va_pbool
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))))
[@ va_qattr]
let va_wp_Psrld (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 < 32) /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Psrld (dst:va_operand_xmm) (amt:int) : (va_quickCode unit (va_code_Psrld dst amt)) =
(va_QProc (va_code_Psrld dst amt) ([va_mod_xmm dst]) (va_wp_Psrld dst amt) (va_wpProof_Psrld dst
amt))
//--
//-- Palignr4
val va_code_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr4 dst src)) =
(va_QProc (va_code_Palignr4 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr4 dst src)
(va_wpProof_Palignr4 dst src))
//--
//-- Palignr8
val va_code_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Palignr8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (forall
(va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl
(va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Palignr8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Palignr8 dst src)) =
(va_QProc (va_code_Palignr8 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Palignr8 dst src)
(va_wpProof_Palignr8 dst src))
//--
//-- VPalignr8
val va_code_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPalignr8 : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPalignr8 (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPalignr8 dst src1 src2)) =
(va_QProc (va_code_VPalignr8 dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPalignr8 dst
src1 src2) (va_wpProof_VPalignr8 dst src1 src2))
//--
//-- Shufpd
val va_code_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Shufpd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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)))))
[@ va_qattr]
let va_wp_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ permutation < 4 /\
sse_enabled /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm
va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if (permutation = 0 ||
permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst))) (va_if
(permutation = 0 || permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1
(va_eval_xmm va_s0 dst)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm
va_s0 dst))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src))) (va_if (permutation = 0 ||
permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src))
(fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src))) ==> va_k va_sM
(())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Shufpd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Shufpd dst src permutation)) =
(va_QProc (va_code_Shufpd dst src permutation) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Shufpd dst
src permutation) (va_wpProof_Shufpd dst src permutation))
//--
//-- VShufpd
val va_code_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
permutation:nat8 -> Tot va_code
val va_codegen_success_VShufpd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> permutation:nat8 -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_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)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour
#Vale.Def.Types_s.nat32 (va_if (permutation = 0 || permutation = 2) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src1)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src1))) (va_if (permutation = 0
|| permutation = 2) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0
src1)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src1))) (va_if
(permutation = 0 || permutation = 1) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__lo0
(va_eval_xmm va_s0 src2)) (fun _ -> Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm
va_s0 src2))) (va_if (permutation = 0 || permutation = 1) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src2)) (fun _ ->
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src2))) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VShufpd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(permutation:nat8) : (va_quickCode unit (va_code_VShufpd dst src1 src2 permutation)) =
(va_QProc (va_code_VShufpd dst src1 src2 permutation) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VShufpd dst src1 src2 permutation) (va_wpProof_VShufpd dst src1 src2 permutation))
//--
//-- Pshufb
val va_code_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Pshufb
dst src)) =
(va_QProc (va_code_Pshufb dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb dst src)
(va_wpProof_Pshufb dst src))
//--
//-- VPshufb
val va_code_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm -> Tot
va_code
val va_codegen_success_VPshufb : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPshufb (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) :
(va_quickCode unit (va_code_VPshufb dst src1 src2)) =
(va_QProc (va_code_VPshufb dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPshufb dst
src1 src2) (va_wpProof_VPshufb dst src1 src2))
//--
//-- PshufbStable
val va_code_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbStable : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbStable (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbStable dst src)) =
(va_QProc (va_code_PshufbStable dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbStable dst
src) (va_wpProof_PshufbStable dst src))
//--
//-- PshufbDup
val va_code_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PshufbDup : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PshufbDup (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PshufbDup dst src)) =
(va_QProc (va_code_PshufbDup dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PshufbDup dst src)
(va_wpProof_PshufbDup dst src))
//--
//-- Pshufb64
val va_code_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pshufb64 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
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)))))
[@ va_qattr]
let va_wp_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(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 /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM
= va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufb64 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pshufb64 dst src)) =
(va_QProc (va_code_Pshufb64 dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_Pshufb64 dst src)
(va_wpProof_Pshufb64 dst src))
//--
//-- Pshufd
val va_code_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot va_code
val va_codegen_success_Pshufd : dst:va_operand_xmm -> src:va_operand_xmm -> permutation:nat8 -> Tot
va_pbool
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))))
[@ va_qattr]
let va_wp_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ 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_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pshufd (dst:va_operand_xmm) (src:va_operand_xmm) (permutation:nat8) : (va_quickCode
unit (va_code_Pshufd dst src permutation)) =
(va_QProc (va_code_Pshufd dst src permutation) ([va_mod_xmm dst]) (va_wp_Pshufd dst src
permutation) (va_wpProof_Pshufd dst src permutation))
//--
//-- Pcmpeqd
val va_code_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Pcmpeqd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Pcmpeqd : 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_Pcmpeqd 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 (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) (if
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) then 4294967295 else 0) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 (va_if
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi2 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) (va_if (Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src) =
Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 dst)) (fun _ -> 4294967295) (fun
_ -> 0)) ==> va_k va_sM (())))
val va_wpProof_Pcmpeqd : 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_Pcmpeqd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pcmpeqd dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pcmpeqd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Pcmpeqd dst src)) =
(va_QProc (va_code_Pcmpeqd dst src) ([va_mod_xmm dst]) (va_wp_Pcmpeqd dst src)
(va_wpProof_Pcmpeqd dst src))
//--
//-- Pextrq
val va_code_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot va_code
val va_codegen_success_Pextrq : dst:va_operand_dst_opr64 -> src:va_operand_xmm -> index:nat8 -> Tot
va_pbool
val va_lemma_Pextrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_xmm -> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pextrq dst src index) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == (if (index = 0) then Vale.Arch.Types.lo64 (va_eval_xmm va_sM
src) else Vale.Arch.Types.hi64 (va_eval_xmm va_sM src)) /\ va_state_eq va_sM (va_update_ok
va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_dst_opr64) . let va_sM = va_upd_operand_dst_opr64 dst
va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_dst_opr64 va_sM dst == va_if (index = 0) (fun _ ->
Vale.Arch.Types.lo64 (va_eval_xmm va_sM src)) (fun _ -> Vale.Arch.Types.hi64 (va_eval_xmm va_sM
src)) ==> va_k va_sM (())))
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))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pextrq (dst:va_operand_dst_opr64) (src:va_operand_xmm) (index:nat8) : (va_quickCode
unit (va_code_Pextrq dst src index)) =
(va_QProc (va_code_Pextrq dst src index) ([va_mod_dst_opr64 dst]) (va_wp_Pextrq dst src index)
(va_wpProof_Pextrq dst src index))
//--
//-- Pinsrd
val va_code_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrd dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ va_eval_opr64 va_s0 src <
pow2_32 /\ index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_s0 src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
va_eval_opr64 va_s0 src < pow2_32 /\ index < 4 /\ (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 /\ va_eval_xmm va_sM dst ==
Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) (va_eval_opr64 va_s0 src) index ==> va_k
va_sM (())))
val va_wpProof_Pinsrd : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrd dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrd dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrd (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrd dst src index)) =
(va_QProc (va_code_Pinsrd dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrd dst src index)
(va_wpProof_Pinsrd dst src index))
//--
//-- PinsrdImm
val va_code_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrdImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat32
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrdImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 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.Types_s.insert_nat32 (va_eval_xmm va_s0 dst) immediate index
/\ va_eval_reg_opr64 va_sM tmp == immediate /\ 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_qattr]
let va_wp_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 4 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat32 (va_eval_xmm va_s0 dst)
immediate index /\ va_eval_reg_opr64 va_sM tmp == immediate ==> va_k va_sM (())))
val va_wpProof_PinsrdImm : dst:va_operand_xmm -> immediate:nat32 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrdImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrdImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrdImm (dst:va_operand_xmm) (immediate:nat32) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrdImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrdImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrdImm dst immediate index tmp) (va_wpProof_PinsrdImm dst immediate index tmp))
//--
//-- Pinsrq
val va_code_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot va_code
val va_codegen_success_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> index:nat8 -> Tot
va_pbool
val va_lemma_Pinsrq : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_opr64
-> index:nat8
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Pinsrq dst src index) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) (va_eval_opr64
va_sM src) index /\ va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0))))
[@ va_qattr]
let va_wp_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ index
< 2 /\ (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 /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0
dst) (va_eval_opr64 va_sM src) index ==> va_k va_sM (())))
val va_wpProof_Pinsrq : dst:va_operand_xmm -> src:va_operand_opr64 -> 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_Pinsrq dst src index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Pinsrq dst src index) ([va_mod_xmm
dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Pinsrq (dst:va_operand_xmm) (src:va_operand_opr64) (index:nat8) : (va_quickCode unit
(va_code_Pinsrq dst src index)) =
(va_QProc (va_code_Pinsrq dst src index) ([va_mod_xmm dst]) (va_wp_Pinsrq dst src index)
(va_wpProof_Pinsrq dst src index))
//--
//-- PinsrqImm
val va_code_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> Tot va_pbool
val va_lemma_PinsrqImm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> immediate:nat64
-> index:nat8 -> tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PinsrqImm dst immediate index tmp) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst) immediate index
/\ 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_qattr]
let va_wp_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8) (tmp:va_operand_reg_opr64)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
index < 2 /\ (forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 tmp va_x_tmp (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok
va_sM /\ va_eval_xmm va_sM dst == Vale.Def.Types_s.insert_nat64 (va_eval_xmm va_s0 dst)
immediate index ==> va_k va_sM (())))
val va_wpProof_PinsrqImm : dst:va_operand_xmm -> immediate:nat64 -> index:nat8 ->
tmp:va_operand_reg_opr64 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PinsrqImm dst immediate index tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PinsrqImm dst immediate index tmp)
([va_mod_reg_opr64 tmp; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PinsrqImm (dst:va_operand_xmm) (immediate:nat64) (index:nat8)
(tmp:va_operand_reg_opr64) : (va_quickCode unit (va_code_PinsrqImm dst immediate index tmp)) =
(va_QProc (va_code_PinsrqImm dst immediate index tmp) ([va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_PinsrqImm dst immediate index tmp) (va_wpProof_PinsrqImm dst immediate index tmp))
//--
//-- VPslldq4
val va_code_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VPslldq4 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VPslldq4 : 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_VPslldq4 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(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)) ==> va_k va_sM (())))
val va_wpProof_VPslldq4 : 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_VPslldq4 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPslldq4 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPslldq4 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VPslldq4 dst src)) =
(va_QProc (va_code_VPslldq4 dst src) ([va_mod_xmm dst]) (va_wp_VPslldq4 dst src)
(va_wpProof_VPslldq4 dst src))
//--
//-- Vpslldq8
val va_code_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpslldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpslldq8 : 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_Vpslldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (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))))
[@ va_qattr]
let va_wp_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0
(Vale.Def.Words_s.__proj__Mkfour__item__lo0 (va_eval_xmm va_s0 src))
(Vale.Def.Words_s.__proj__Mkfour__item__lo1 (va_eval_xmm va_s0 src)) ==> va_k va_sM (())))
val va_wpProof_Vpslldq8 : 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_Vpslldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpslldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpslldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpslldq8 dst src)) =
(va_QProc (va_code_Vpslldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpslldq8 dst src)
(va_wpProof_Vpslldq8 dst src))
//--
//-- Vpsrldq8
val va_code_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Vpsrldq8 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Vpsrldq8 : 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_Vpsrldq8 dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src 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 src))
(Vale.Def.Words_s.__proj__Mkfour__item__hi3 (va_eval_xmm va_s0 src)) 0 0 /\ va_state_eq va_sM
(va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ avx_enabled /\ (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
/\ 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)) 0 0 ==> va_k va_sM (())))
val va_wpProof_Vpsrldq8 : 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_Vpsrldq8 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Vpsrldq8 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_Vpsrldq8 dst src)) =
(va_QProc (va_code_Vpsrldq8 dst src) ([va_mod_xmm dst]) (va_wp_Vpsrldq8 dst src)
(va_wpProof_Vpsrldq8 dst src))
//--
//-- Mov128
val va_code_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_Mov128 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_Mov128 : 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_Mov128 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 == 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))))
[@ va_qattr]
let va_wp_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\ (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
/\ va_eval_xmm va_sM dst == va_eval_xmm va_s0 src ==> va_k va_sM (())))
val va_wpProof_Mov128 : 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_Mov128 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Mov128 dst src) ([va_mod_xmm dst])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Mov128 (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_Mov128
dst src)) =
(va_QProc (va_code_Mov128 dst src) ([va_mod_xmm dst]) (va_wp_Mov128 dst src) (va_wpProof_Mov128
dst src))
//--
//-- Load128_buffer
val va_code_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm -> src:va_operand_reg_opr64
-> offset:int -> t:taint -> Tot va_code
val va_codegen_success_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> Tot va_pbool
val va_lemma_Load128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_xmm -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> b:buffer128 ->
index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Load128_buffer h dst src offset t) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(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.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_xmm) (src:va_operand_reg_opr64)
(offset:int) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_xmm dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (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
/\ va_eval_xmm va_sM dst == Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h) ==>
va_k va_sM (())))
val va_wpProof_Load128_buffer : h:va_operand_heaplet -> dst:va_operand_xmm ->
src:va_operand_reg_opr64 -> 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_Load128_buffer h dst src offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Load128_buffer h dst src offset t)
([va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Load128_buffer (h:va_operand_heaplet) (dst:va_operand_xmm) (src:va_operand_reg_opr64)
(offset:int) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit (va_code_Load128_buffer h
dst src offset t)) =
(va_QProc (va_code_Load128_buffer h dst src offset t) ([va_mod_xmm dst]) (va_wp_Load128_buffer h
dst src offset t b index) (va_wpProof_Load128_buffer h dst src offset t b index))
//--
//-- LoadBe64_buffer128
val va_code_LoadBe64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_code
val va_codegen_success_LoadBe64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_pbool
val va_lemma_LoadBe64_buffer128 : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_reg_opr64 -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_LoadBe64_buffer128 h dst src offset t upper) va_s0 /\
va_is_src_heaplet h va_s0 /\ va_is_dst_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ movbe_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index + (if upper then
8 else 0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_reg_opr64 va_sM dst == Vale.Def.Types_s.reverse_bytes_nat64 (if upper then
Vale.Arch.Types.hi64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h)) else
Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h))) /\
va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr64 dst va_sM va_s0))))
[@ va_qattr]
let va_wp_LoadBe64_buffer128 (h:va_operand_heaplet) (dst:va_operand_reg_opr64)
(src:va_operand_reg_opr64) (offset:int) (t:taint) (upper:bool) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_src_heaplet h va_s0 /\ va_is_dst_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ movbe_enabled /\ Vale.X64.Decls.valid_src_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) false /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 src + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index + va_if upper
(fun _ -> 8) (fun _ -> 0) /\ (forall (va_x_dst:va_value_reg_opr64) . let va_sM =
va_upd_operand_reg_opr64 dst va_x_dst va_s0 in va_get_ok va_sM /\ va_eval_reg_opr64 va_sM dst
== Vale.Def.Types_s.reverse_bytes_nat64 (va_if upper (fun _ -> Vale.Arch.Types.hi64
(Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h))) (fun _ ->
Vale.Arch.Types.lo64 (Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_sM h)))) ==>
va_k va_sM (())))
val va_wpProof_LoadBe64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_LoadBe64_buffer128 h dst src offset t upper b index va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_LoadBe64_buffer128 h dst src offset t
upper) ([va_mod_reg_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_LoadBe64_buffer128 (h:va_operand_heaplet) (dst:va_operand_reg_opr64)
(src:va_operand_reg_opr64) (offset:int) (t:taint) (upper:bool) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_LoadBe64_buffer128 h dst src offset t upper)) =
(va_QProc (va_code_LoadBe64_buffer128 h dst src offset t upper) ([va_mod_reg_opr64 dst])
(va_wp_LoadBe64_buffer128 h dst src offset t upper b index) (va_wpProof_LoadBe64_buffer128 h
dst src offset t upper b index))
//--
//-- Store128_buffer
val va_code_Store128_buffer : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_xmm -> offset:int -> t:taint -> Tot va_code
val va_codegen_success_Store128_buffer : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_xmm -> offset:int -> t:taint -> Tot va_pbool
val va_lemma_Store128_buffer : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_reg_opr64 -> src:va_operand_xmm -> offset:int -> t:taint -> b:buffer128 ->
index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store128_buffer h dst src offset t) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_reg_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_dst_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 dst + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (va_eval_xmm va_s0 src) (va_eval_heaplet
va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM (va_update_ok va_sM
(va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store128_buffer (h:va_operand_heaplet) (dst:va_operand_reg_opr64) (src:va_operand_xmm)
(offset:int) (t:taint) (b:buffer128) (index:int) (va_s0:va_state) (va_k:(va_state -> unit ->
Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_reg_opr64 dst va_s0 /\ va_is_src_xmm src va_s0 /\
va_get_ok va_s0 /\ sse_enabled /\ Vale.X64.Decls.valid_dst_addr #Vale.X64.Memory.vuint128
(va_eval_heaplet va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer
#Vale.X64.Memory.vuint128 b (va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\
Vale.X64.Memory.valid_taint_buf128 b (va_eval_heaplet va_s0 h) ((va_get_mem_layout
va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0 dst + offset == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0 h) + 16 `op_Multiply` index /\ (forall
(va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem
(va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\ va_eval_heaplet va_sM h ==
buffer128_write b index (va_eval_xmm va_s0 src) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store128_buffer : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_xmm -> 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_Store128_buffer h dst src offset t b index va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store128_buffer h dst src offset t)
([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store128_buffer (h:va_operand_heaplet) (dst:va_operand_reg_opr64) (src:va_operand_xmm)
(offset:int) (t:taint) (b:buffer128) (index:int) : (va_quickCode unit (va_code_Store128_buffer h
dst src offset t)) =
(va_QProc (va_code_Store128_buffer h dst src offset t) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store128_buffer h dst src offset t b index) (va_wpProof_Store128_buffer h dst src offset
t b index))
//--
//-- Store64_buffer128
val va_code_Store64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_code
val va_codegen_success_Store64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> Tot va_pbool
val va_lemma_Store64_buffer128 : va_b0:va_code -> va_s0:va_state -> h:va_operand_heaplet ->
dst:va_operand_reg_opr64 -> src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool ->
b:buffer128 -> index:int
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Store64_buffer128 h dst src offset t upper) va_s0 /\
va_is_dst_heaplet h va_s0 /\ va_is_src_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.valid_dst_addr #Vale.X64.Memory.vuint128 (va_eval_heaplet
va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer #Vale.X64.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.X64.Memory.valid_taint_buf128
b (va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0
dst + offset == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0
h) + 16 `op_Multiply` index + (if upper then 8 else 0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_heaplet va_sM h == buffer128_write b index (Vale.Def.Types_s.insert_nat64
(Vale.X64.Decls.buffer128_read b index (va_eval_heaplet va_s0 h)) (va_eval_reg_opr64 va_s0 src)
(if upper then 1 else 0)) (va_eval_heaplet va_s0 h) /\ va_state_eq va_sM (va_update_mem va_sM
(va_update_ok va_sM (va_update_operand_heaplet h va_sM va_s0)))))
[@ va_qattr]
let va_wp_Store64_buffer128 (h:va_operand_heaplet) (dst:va_operand_reg_opr64)
(src:va_operand_reg_opr64) (offset:int) (t:taint) (upper:bool) (b:buffer128) (index:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_heaplet h va_s0 /\ va_is_src_reg_opr64 dst va_s0 /\ va_is_src_reg_opr64 src va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.valid_dst_addr #Vale.X64.Memory.vuint128 (va_eval_heaplet
va_s0 h) b index /\ Vale.X64.Memory.valid_layout_buffer #Vale.X64.Memory.vuint128 b
(va_get_mem_layout va_s0) (va_eval_heaplet va_s0 h) true /\ Vale.X64.Memory.valid_taint_buf128
b (va_eval_heaplet va_s0 h) ((va_get_mem_layout va_s0).vl_taint) t /\ va_eval_reg_opr64 va_s0
dst + offset == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 b (va_eval_heaplet va_s0
h) + 16 `op_Multiply` index + va_if upper (fun _ -> 8) (fun _ -> 0) /\ (forall
(va_x_h:va_value_heaplet) (va_x_mem:vale_heap) . let va_sM = va_upd_mem va_x_mem
(va_upd_operand_heaplet h va_x_h va_s0) in va_get_ok va_sM /\ va_eval_heaplet va_sM h ==
buffer128_write b index (Vale.Def.Types_s.insert_nat64 (Vale.X64.Decls.buffer128_read b index
(va_eval_heaplet va_s0 h)) (va_eval_reg_opr64 va_s0 src) (va_if upper (fun _ -> 1) (fun _ ->
0))) (va_eval_heaplet va_s0 h) ==> va_k va_sM (())))
val va_wpProof_Store64_buffer128 : h:va_operand_heaplet -> dst:va_operand_reg_opr64 ->
src:va_operand_reg_opr64 -> offset:int -> t:taint -> upper:bool -> b:buffer128 -> index:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Store64_buffer128 h dst src offset t upper b index va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Store64_buffer128 h dst src offset t
upper) ([va_Mod_mem; va_mod_heaplet h]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Store64_buffer128 (h:va_operand_heaplet) (dst:va_operand_reg_opr64)
(src:va_operand_reg_opr64) (offset:int) (t:taint) (upper:bool) (b:buffer128) (index:int) :
(va_quickCode unit (va_code_Store64_buffer128 h dst src offset t upper)) =
(va_QProc (va_code_Store64_buffer128 h dst src offset t upper) ([va_Mod_mem; va_mod_heaplet h])
(va_wp_Store64_buffer128 h dst src offset t upper b index) (va_wpProof_Store64_buffer128 h dst
src offset t upper b index))
//--
//-- ZeroXmm
val va_code_ZeroXmm : dst:va_operand_xmm -> Tot va_code
val va_codegen_success_ZeroXmm : dst:va_operand_xmm -> Tot va_pbool
val va_lemma_ZeroXmm : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_ZeroXmm dst) va_s0 /\ va_is_dst_xmm dst 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 0 0 0 0 /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsVector.fsti"
} | [
{
"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": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
dst: Vale.X64.Decls.va_operand_xmm ->
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",
"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.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_eval_xmm",
"Vale.Def.Words_s.Mkfour",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | false | false | false | true | true | let va_wp_ZeroXmm (dst: va_operand_xmm) (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 /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
va_eval_xmm va_sM dst == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0 ==>
va_k va_sM (()))) | false |
Vale.X64.InsStack.fsti | Vale.X64.InsStack.va_wp_Stack_lemma | val va_wp_Stack_lemma
(base: operand64)
(offset: int)
(t: taint)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Stack_lemma
(base: operand64)
(offset: int)
(t: taint)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Stack_lemma (base:operand64) (offset:int) (t:taint) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let va_sM = va_s0 in va_get_ok va_sM ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.X64.InsStack.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 32,
"start_col": 0,
"start_line": 30
} | module Vale.X64.InsStack
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.QuickCode
open Vale.X64.InsBasic
open Vale.X64.InsVector
open Vale.X64.CPU_Features_s
//-- Stack_lemma
val va_code_Stack_lemma : va_dummy:unit -> Tot va_code
val va_codegen_success_Stack_lemma : va_dummy:unit -> Tot va_pbool
val va_lemma_Stack_lemma : va_b0:va_code -> va_s0:va_state -> base:operand64 -> offset:int ->
t:taint
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Stack_lemma ()) va_s0 /\ va_get_ok va_s0))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_state_eq va_sM (va_update_ok va_sM va_s0))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.InsStack.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"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.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": 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 |
base: Vale.X64.Machine_s.operand64 ->
offset: Prims.int ->
t: Vale.Arch.HeapTypes_s.taint ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Prims.int",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.l_imp",
"Vale.X64.State.vale_state"
] | [] | false | false | false | true | true | let va_wp_Stack_lemma
(base: operand64)
(offset: int)
(t: taint)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
(let va_sM = va_s0 in
va_get_ok va_sM ==> va_k va_sM (()))) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.