effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val unsquash_term (t: term) : option term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val unsquash_term (t: term) : option term
let unsquash_term (t: term) : option term = | false | null | false | 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 | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.V2.Derived.is_name_imp",
"FStar.Reflection.Const.squash_qn",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Reflection.V2.Data.term_view"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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]. *) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val unsquash_term (t: term) : option term | [] | FStar.Reflection.V2.Derived.unsquash_term | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term -> FStar.Pervasives.Native.option FStar.Reflection.Types.term | {
"end_col": 15,
"end_line": 288,
"start_col": 4,
"start_line": 283
} |
Prims.Tot | val u_unk:universe | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let u_unk : universe = pack_universe Uv_Unk | val u_unk:universe
let u_unk:universe = | false | null | false | pack_universe Uv_Unk | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.V2.Builtins.pack_universe",
"FStar.Reflection.V2.Data.Uv_Unk"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val u_unk:universe | [] | FStar.Reflection.V2.Derived.u_unk | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.Reflection.Types.universe | {
"end_col": 43,
"end_line": 110,
"start_col": 23,
"start_line": 110
} |
Prims.Tot | val collect_abs_ln : term -> list binder * term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let collect_abs_ln t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t') | val collect_abs_ln : term -> list binder * term
let collect_abs_ln t = | false | null | false | let bs, t' = collect_abs' [] t in
(List.Tot.Base.rev bs, t') | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"Prims.list",
"FStar.Reflection.Types.binder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.Tot.Base.rev",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.Derived.collect_abs'",
"Prims.Nil"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_abs_ln : term -> list binder * term | [] | FStar.Reflection.V2.Derived.collect_abs_ln | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term
-> Prims.list FStar.Reflection.Types.binder * FStar.Reflection.Types.term | {
"end_col": 30,
"end_line": 153,
"start_col": 22,
"start_line": 151
} |
Prims.Tot | val mk_implicit_binder (nm: string) (sort: typ) : binder | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let mk_implicit_binder (nm : string) (sort : typ) : binder =
pack_binder {
ppname = seal nm;
qual = Q_Implicit;
attrs = [];
sort = sort;
} | val mk_implicit_binder (nm: string) (sort: typ) : binder
let mk_implicit_binder (nm: string) (sort: typ) : binder = | false | null | false | pack_binder ({ ppname = seal nm; qual = Q_Implicit; attrs = []; sort = sort }) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"Prims.string",
"FStar.Reflection.Types.typ",
"FStar.Reflection.V2.Builtins.pack_binder",
"FStar.Reflection.V2.Data.Mkbinder_view",
"FStar.Reflection.V2.Data.Q_Implicit",
"Prims.Nil",
"FStar.Reflection.Types.term",
"FStar.Sealed.seal",
"FStar.Reflection.Types.binder"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_implicit_binder (nm: string) (sort: typ) : binder | [] | FStar.Reflection.V2.Derived.mk_implicit_binder | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | nm: Prims.string -> sort: FStar.Reflection.Types.typ -> FStar.Reflection.Types.binder | {
"end_col": 3,
"end_line": 69,
"start_col": 2,
"start_line": 64
} |
Prims.Tot | val inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv}
let rec inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv} = | false | null | false | match inspect_ln t with
| Tv_AscribedT t' _ _ _ | Tv_AscribedC t' _ _ _ -> inspect_ln_unascribe t'
| tv -> tv | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Builtins.inspect_ln",
"FStar.Pervasives.Native.option",
"Prims.bool",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.Types.comp",
"FStar.Reflection.V2.Data.term_view",
"Prims.l_and",
"Prims.precedes",
"Prims.b2t",
"FStar.Reflection.V2.Data.notAscription"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.Reflection.V2.Data
open FStar.Order
open FStar.VConfig | false | false | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inspect_ln_unascribe (t: term) : tv: term_view{tv << t /\ notAscription tv} | [
"recursion"
] | FStar.Reflection.V2.Derived.inspect_ln_unascribe | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term
-> tv: FStar.Reflection.V2.Data.term_view{tv << t /\ FStar.Reflection.V2.Data.notAscription tv} | {
"end_col": 14,
"end_line": 29,
"start_col": 4,
"start_line": 26
} |
Prims.Tot | val flatten_name : name -> Tot string | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let rec flatten_name ns =
match ns with
| [] -> ""
| [n] -> n
| n::ns -> n ^ "." ^ flatten_name ns | val flatten_name : name -> Tot string
let rec flatten_name ns = | false | null | false | match ns with
| [] -> ""
| [n] -> n
| n :: ns -> n ^ "." ^ flatten_name ns | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.name",
"Prims.string",
"Prims.list",
"Prims.op_Hat",
"FStar.Reflection.V2.Derived.flatten_name"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val flatten_name : name -> Tot string | [
"recursion"
] | FStar.Reflection.V2.Derived.flatten_name | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | ns: FStar.Reflection.Types.name -> Prims.string | {
"end_col": 40,
"end_line": 88,
"start_col": 4,
"start_line": 85
} |
Prims.Tot | val mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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)))) | val mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs)
let rec mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs) = | false | null | false | match bs with
| [] -> cod
| b :: bs -> pack_ln (Tv_Arrow b (pack_comp (C_Total (mk_tot_arr_ln bs cod)))) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"Prims.list",
"FStar.Reflection.Types.binder",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Builtins.pack_ln",
"FStar.Reflection.V2.Data.Tv_Arrow",
"FStar.Reflection.V2.Builtins.pack_comp",
"FStar.Reflection.V2.Data.C_Total",
"FStar.Reflection.V2.Derived.mk_tot_arr_ln"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_tot_arr_ln (bs: list binder) (cod: term) : Tot term (decreases bs) | [
"recursion"
] | FStar.Reflection.V2.Derived.mk_tot_arr_ln | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Reflection.Types.binder -> cod: FStar.Reflection.Types.term
-> Prims.Tot FStar.Reflection.Types.term | {
"end_col": 82,
"end_line": 115,
"start_col": 4,
"start_line": 113
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 n s = | false | null | false | 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 | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"Prims.int",
"FStar.Stubs.Syntax.Syntax.subst_elt",
"FStar.Reflection.Types.namedv",
"FStar.Stubs.Syntax.Syntax.DB",
"Prims.op_Addition",
"FStar.Reflection.Types.term",
"FStar.Stubs.Syntax.Syntax.DT",
"FStar.Reflection.Types.universe",
"FStar.Stubs.Syntax.Syntax.UN",
"FStar.Stubs.Syntax.Syntax.NM",
"FStar.Reflection.Types.ident",
"FStar.Stubs.Syntax.Syntax.UD"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shift : n: Prims.int -> s: FStar.Stubs.Syntax.Syntax.subst_elt -> FStar.Stubs.Syntax.Syntax.subst_elt | [] | FStar.Reflection.V2.Derived.shift | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | n: Prims.int -> s: FStar.Stubs.Syntax.Syntax.subst_elt -> FStar.Stubs.Syntax.Syntax.subst_elt | {
"end_col": 17,
"end_line": 43,
"start_col": 16,
"start_line": 37
} |
|
Prims.Tot | val mk_list (ts: list term) : term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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) | val mk_list (ts: list term) : term
let rec mk_list (ts: list term) : term = | false | null | false | match ts with
| [] -> pack_ln (Tv_FVar (pack_fv nil_qn))
| t :: ts -> mk_cons t (mk_list ts) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"Prims.list",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Builtins.pack_ln",
"FStar.Reflection.V2.Data.Tv_FVar",
"FStar.Reflection.V2.Builtins.pack_fv",
"FStar.Reflection.Const.nil_qn",
"FStar.Reflection.V2.Derived.mk_cons",
"FStar.Reflection.V2.Derived.mk_list"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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)] | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_list (ts: list term) : term | [
"recursion"
] | FStar.Reflection.V2.Derived.mk_list | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | ts: Prims.list FStar.Reflection.Types.term -> FStar.Reflection.Types.term | {
"end_col": 37,
"end_line": 172,
"start_col": 4,
"start_line": 170
} |
Prims.Tot | val mk_binder (nm: string) (sort: typ) : simple_binder | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val mk_binder (nm: string) (sort: typ) : simple_binder
let mk_binder (nm: string) (sort: typ) : simple_binder = | false | null | false | let bv:binder_view = { ppname = seal nm; qual = Q_Explicit; attrs = []; sort = sort } in
inspect_pack_binder bv;
pack_binder bv | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"Prims.string",
"FStar.Reflection.Types.typ",
"FStar.Reflection.V2.Builtins.pack_binder",
"Prims.unit",
"FStar.Reflection.V2.Builtins.inspect_pack_binder",
"FStar.Reflection.V2.Data.binder_view",
"FStar.Reflection.V2.Data.Mkbinder_view",
"FStar.Reflection.V2.Data.Q_Explicit",
"Prims.Nil",
"FStar.Reflection.Types.term",
"FStar.Sealed.seal",
"FStar.Reflection.V2.Data.simple_binder"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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? | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_binder (nm: string) (sort: typ) : simple_binder | [] | FStar.Reflection.V2.Derived.mk_binder | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | nm: Prims.string -> sort: FStar.Reflection.Types.typ -> FStar.Reflection.V2.Data.simple_binder | {
"end_col": 16,
"end_line": 61,
"start_col": 58,
"start_line": 52
} |
Prims.Tot | val mk_app (t: term) (args: list argv) : Tot term (decreases args) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val mk_app (t: term) (args: list argv) : Tot term (decreases args)
let rec mk_app (t: term) (args: list argv) : Tot term (decreases args) = | false | null | false | match args with
| [] -> t
| x :: xs -> mk_app (pack_ln (Tv_App t x)) xs | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"FStar.Reflection.Types.term",
"Prims.list",
"FStar.Reflection.V2.Data.argv",
"FStar.Reflection.V2.Derived.mk_app",
"FStar.Reflection.V2.Builtins.pack_ln",
"FStar.Reflection.V2.Data.Tv_App"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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' [] | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_app (t: term) (args: list argv) : Tot term (decreases args) | [
"recursion"
] | FStar.Reflection.V2.Derived.mk_app | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term -> args: Prims.list FStar.Reflection.V2.Data.argv
-> Prims.Tot FStar.Reflection.Types.term | {
"end_col": 49,
"end_line": 103,
"start_col": 4,
"start_line": 101
} |
Prims.Tot | val collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t)
let rec collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t) = | false | null | false | match inspect_ln_unascribe t with
| Tv_Abs b t' -> collect_abs' (b :: bs) t'
| _ -> (bs, t) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"Prims.list",
"FStar.Reflection.Types.binder",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.V2.Derived.collect_abs'",
"Prims.Cons",
"FStar.Reflection.V2.Data.term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_abs' (bs: list binder) (t: term) : Tot (list binder * term) (decreases t) | [
"recursion"
] | FStar.Reflection.V2.Derived.collect_abs' | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Reflection.Types.binder -> t: FStar.Reflection.Types.term
-> Prims.Tot (Prims.list FStar.Reflection.Types.binder * FStar.Reflection.Types.term) | {
"end_col": 18,
"end_line": 148,
"start_col": 4,
"start_line": 145
} |
Prims.Tot | val is_any_fvar (t: term) (nms: list string) : bool | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | 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 | val is_any_fvar (t: term) (nms: list string) : bool
let rec is_any_fvar (t: term) (nms: list string) : bool = | false | null | false | match nms with
| [] -> false
| v :: vs -> is_fvar t v || is_any_fvar t vs | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.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"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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. *) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_any_fvar (t: term) (nms: list string) : bool | [
"recursion"
] | FStar.Reflection.V2.Derived.is_any_fvar | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term -> nms: Prims.list Prims.string -> Prims.bool | {
"end_col": 46,
"end_line": 241,
"start_col": 4,
"start_line": 239
} |
Prims.Tot | val collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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' (args: list argv) (t: term) : Tot (term * list argv) (decreases t)
let rec collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t) = | false | null | false | match inspect_ln_unascribe t with
| Tv_App l r -> collect_app_ln' (r :: args) l
| _ -> (t, args) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"Prims.list",
"FStar.Reflection.V2.Data.argv",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.V2.Derived.collect_app_ln'",
"Prims.Cons",
"FStar.Reflection.V2.Data.term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 *) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_app_ln' (args: list argv) (t: term) : Tot (term * list argv) (decreases t) | [
"recursion"
] | FStar.Reflection.V2.Derived.collect_app_ln' | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | args: Prims.list FStar.Reflection.V2.Data.argv -> t: FStar.Reflection.Types.term
-> Prims.Tot (FStar.Reflection.Types.term * Prims.list FStar.Reflection.V2.Data.argv) | {
"end_col": 20,
"end_line": 95,
"start_col": 4,
"start_line": 92
} |
Prims.Tot | val collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c)
let rec collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c) = | false | null | false | match inspect_comp c with
| C_Total t ->
(match inspect_ln_unascribe t with
| Tv_Arrow b c -> collect_arr' (b :: bs) c
| _ -> (bs, c))
| _ -> (bs, c) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"Prims.list",
"FStar.Reflection.Types.binder",
"FStar.Reflection.Types.comp",
"FStar.Reflection.V2.Builtins.inspect_comp",
"FStar.Reflection.Types.typ",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.V2.Derived.collect_arr'",
"Prims.Cons",
"FStar.Reflection.V2.Data.term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.Data.comp_view"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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)))) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_arr' (bs: list binder) (c: comp) : Tot (list binder * comp) (decreases c) | [
"recursion"
] | FStar.Reflection.V2.Derived.collect_arr' | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Reflection.Types.binder -> c: FStar.Reflection.Types.comp
-> Prims.Tot (Prims.list FStar.Reflection.Types.binder * FStar.Reflection.Types.comp) | {
"end_col": 18,
"end_line": 131,
"start_col": 10,
"start_line": 123
} |
Prims.Tot | val destruct_tuple (t: term) : option (list term) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val destruct_tuple (t: term) : option (list term)
let destruct_tuple (t: term) : option (list term) = | false | null | false | 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": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"Prims.list",
"FStar.Reflection.V2.Data.argv",
"FStar.Reflection.V2.Builtins.inspect_ln",
"FStar.Reflection.Types.fv",
"FStar.List.Tot.Base.mem",
"Prims.string",
"FStar.Reflection.V2.Builtins.inspect_fv",
"Prims.Cons",
"FStar.Reflection.Const.mktuple2_qn",
"FStar.Reflection.Const.mktuple3_qn",
"FStar.Reflection.Const.mktuple4_qn",
"FStar.Reflection.Const.mktuple5_qn",
"FStar.Reflection.Const.mktuple6_qn",
"FStar.Reflection.Const.mktuple7_qn",
"FStar.Reflection.Const.mktuple8_qn",
"Prims.Nil",
"FStar.Pervasives.Native.Some",
"FStar.List.Tot.Base.concatMap",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.Data.aqualv",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Reflection.V2.Data.term_view",
"FStar.Reflection.V2.Derived.collect_app_ln"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val destruct_tuple (t: term) : option (list term) | [] | FStar.Reflection.V2.Derived.destruct_tuple | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term
-> FStar.Pervasives.Native.option (Prims.list FStar.Reflection.Types.term) | {
"end_col": 15,
"end_line": 202,
"start_col": 52,
"start_line": 190
} |
Prims.Tot | val mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs) | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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)))) | val mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs)
let rec mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs) = | false | null | false | 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)))) | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total",
""
] | [
"Prims.list",
"FStar.Reflection.Types.binder",
"Prims.l_not",
"Prims.b2t",
"Prims.uu___is_Nil",
"FStar.Reflection.Types.comp",
"FStar.Reflection.V2.Builtins.pack_ln",
"FStar.Reflection.V2.Data.Tv_Arrow",
"FStar.Reflection.V2.Builtins.pack_comp",
"FStar.Reflection.V2.Data.C_Total",
"FStar.Reflection.V2.Derived.mk_arr_ln",
"FStar.Reflection.Types.term"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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)))) | false | false | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_arr_ln (bs: list binder {~(Nil? bs)}) (cod: comp) : Tot term (decreases bs) | [
"recursion"
] | FStar.Reflection.V2.Derived.mk_arr_ln | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Reflection.Types.binder {~(Nil? bs)} -> cod: FStar.Reflection.Types.comp
-> Prims.Tot FStar.Reflection.Types.term | {
"end_col": 78,
"end_line": 120,
"start_col": 4,
"start_line": 118
} |
Prims.Tot | val mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term
let mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term = | false | null | false | match List.Tot.Base.length ts with
| 0 -> pack_ln (Tv_Const C_Unit)
| 1 ->
let [x] = ts in
x
| n ->
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 | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"Prims.list",
"FStar.Reflection.Types.term",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.List.Tot.Base.length",
"FStar.Reflection.V2.Builtins.pack_ln",
"FStar.Reflection.V2.Data.Tv_Const",
"FStar.Reflection.V2.Data.C_Unit",
"Prims.int",
"FStar.Reflection.V2.Derived.mk_e_app",
"FStar.Reflection.V2.Data.Tv_FVar",
"FStar.Reflection.V2.Builtins.pack_fv",
"FStar.Reflection.Types.name",
"FStar.Reflection.Const.mktuple2_qn",
"FStar.Reflection.Const.mktuple3_qn",
"FStar.Reflection.Const.mktuple4_qn",
"FStar.Reflection.Const.mktuple5_qn",
"FStar.Reflection.Const.mktuple6_qn",
"FStar.Reflection.Const.mktuple7_qn",
"FStar.Reflection.Const.mktuple8_qn"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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) | false | false | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mktuple_n (ts: list term {List.Tot.Base.length ts <= 8}) : term | [] | FStar.Reflection.V2.Derived.mktuple_n | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | ts: Prims.list FStar.Reflection.Types.term {FStar.List.Tot.Base.length ts <= 8}
-> FStar.Reflection.Types.term | {
"end_col": 14,
"end_line": 188,
"start_col": 4,
"start_line": 175
} |
Prims.Tot | val is_name_imp (nm: name) (t: term) : bool | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | 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 | val is_name_imp (nm: name) (t: term) : bool
let rec is_name_imp (nm: name) (t: term) : bool = | false | null | false | 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 | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.name",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.inspect_ln_unascribe",
"FStar.Reflection.Types.fv",
"Prims.op_Equality",
"FStar.Reflection.V2.Builtins.inspect_fv",
"Prims.bool",
"FStar.Reflection.V2.Data.universes",
"FStar.Reflection.V2.Derived.is_name_imp",
"FStar.Reflection.V2.Data.term_view"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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.
*) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_name_imp (nm: name) (t: term) : bool | [
"recursion"
] | FStar.Reflection.V2.Derived.is_name_imp | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | nm: FStar.Reflection.Types.name -> t: FStar.Reflection.Types.term -> Prims.bool | {
"end_col": 16,
"end_line": 277,
"start_col": 10,
"start_line": 269
} |
Prims.Tot | val maybe_unsquash_term (t: term) : term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let maybe_unsquash_term (t : term) : term =
match unsquash_term t with
| Some t' -> t'
| None -> t | val maybe_unsquash_term (t: term) : term
let maybe_unsquash_term (t: term) : term = | false | null | false | match unsquash_term t with
| Some t' -> t'
| None -> t | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.unsquash_term"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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
[t] is not a squash. *) | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_unsquash_term (t: term) : term | [] | FStar.Reflection.V2.Derived.maybe_unsquash_term | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term -> FStar.Reflection.Types.term | {
"end_col": 15,
"end_line": 295,
"start_col": 4,
"start_line": 293
} |
Prims.Tot | val head (t: term) : term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | 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 | val head (t: term) : term
let rec head (t: term) : term = | false | null | false | 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 | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Builtins.inspect_ln",
"FStar.Pervasives.Native.option",
"FStar.Reflection.Types.match_returns_ascription",
"Prims.list",
"FStar.Reflection.V2.Data.branch",
"FStar.Reflection.V2.Derived.head",
"Prims.bool",
"FStar.Reflection.V2.Data.simple_binder",
"FStar.Reflection.Types.binder",
"FStar.Reflection.V2.Data.argv",
"FStar.Reflection.Types.comp",
"Prims.nat",
"FStar.Reflection.Types.ctx_uvar_and_subst",
"FStar.Reflection.V2.Data.vconst",
"FStar.Reflection.Types.universe",
"FStar.Reflection.Types.namedv",
"FStar.Reflection.Types.bv",
"FStar.Reflection.Types.fv",
"FStar.Reflection.V2.Data.universes"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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] | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val head (t: term) : term | [
"recursion"
] | FStar.Reflection.V2.Derived.head | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.term -> FStar.Reflection.Types.term | {
"end_col": 20,
"end_line": 226,
"start_col": 4,
"start_line": 208
} |
Prims.Tot | val mkpair (t1 t2: term) : term | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Order",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Data",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.Const",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.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
}
] | false | let mkpair (t1 t2 : term) : term =
mktuple_n [t1;t2] | val mkpair (t1 t2: term) : term
let mkpair (t1 t2: term) : term = | false | null | false | mktuple_n [t1; t2] | {
"checked_file": "FStar.Reflection.V2.Derived.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.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"
} | [
"total"
] | [
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.mktuple_n",
"Prims.Cons",
"Prims.Nil"
] | [] | (*
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.Reflection.Types
open FStar.Reflection.Const
open FStar.Reflection.V2.Builtins
open FStar.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 | false | true | FStar.Reflection.V2.Derived.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mkpair (t1 t2: term) : term | [] | FStar.Reflection.V2.Derived.mkpair | {
"file_name": "ulib/FStar.Reflection.V2.Derived.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t1: FStar.Reflection.Types.term -> t2: FStar.Reflection.Types.term -> FStar.Reflection.Types.term | {
"end_col": 21,
"end_line": 205,
"start_col": 4,
"start_line": 205
} |
Prims.Tot | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
let pts_to
(#a: Type)
(#p: Preorder.preorder a)
(r: ref a p)
([@@@ smt_fallback]f: perm)
([@@@ smt_fallback]v: a)
: vprop = | false | null | false | MR.pts_to #a #p r f v | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.GhostMonotonicReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | [] | Steel.ST.GhostMonotonicReference.pts_to | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.GhostMonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | {
"end_col": 26,
"end_line": 34,
"start_col": 5,
"start_line": 34
} |
Prims.Tot | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
let ref (a: Type u#0) (p: Preorder.preorder a) : Type u#0 = | false | null | false | MR.ref a p | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.GhostMonotonicReference.ref"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | [] | Steel.ST.GhostMonotonicReference.ref | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type0 -> p: FStar.Preorder.preorder a -> Type0 | {
"end_col": 14,
"end_line": 26,
"start_col": 4,
"start_line": 26
} |
Prims.Tot | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0
let witnessed (#a: Type u#0) (#p: Preorder.preorder a) (r: ref a p) (fact: property a) : Type0 = | false | null | false | MR.witnessed r fact | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.ST.GhostMonotonicReference.property",
"Steel.GhostMonotonicReference.witnessed"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | [] | Steel.ST.GhostMonotonicReference.witnessed | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.GhostMonotonicReference.ref a p -> fact: Steel.ST.GhostMonotonicReference.property a
-> Type0 | {
"end_col": 23,
"end_line": 55,
"start_col": 4,
"start_line": 55
} |
Steel.ST.Effect.Atomic.STAtomicU | val recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
: STAtomicU unit inames
(pts_to r q v)
(fun _ -> pts_to r q v)
(requires True)
(ensures fun _ -> fact v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | val recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
: STAtomicU unit inames
(pts_to r q v)
(fun _ -> pts_to r q v)
(requires True)
(ensures fun _ -> fact v)
let recall
(#inames: _)
(#a: Type u#0)
(#q: perm)
(#p: Preorder.preorder a)
(fact: property a)
(r: ref a p)
(v: erased a)
(w: witnessed r fact)
= | true | null | false | coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.property",
"Steel.ST.GhostMonotonicReference.ref",
"FStar.Ghost.erased",
"Steel.ST.GhostMonotonicReference.witnessed",
"Steel.ST.Coercions.coerce_atomic",
"Prims.unit",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.GhostMonotonicReference.pts_to_sl",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.GhostMonotonicReference.recall"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf)
let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
: STAtomicU unit inames
(pts_to r q v)
(fun _ -> pts_to r q v)
(requires True)
(ensures fun _ -> fact v) | [] | Steel.ST.GhostMonotonicReference.recall | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
fact: Steel.ST.GhostMonotonicReference.property a ->
r: Steel.ST.GhostMonotonicReference.ref a p ->
v: FStar.Ghost.erased a ->
w: Steel.ST.GhostMonotonicReference.witnessed r fact
-> Steel.ST.Effect.Atomic.STAtomicU Prims.unit | {
"end_col": 66,
"end_line": 89,
"start_col": 4,
"start_line": 89
} |
Steel.ST.Effect.Atomic.STAtomicUT | val witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(_:squash (fact v))
: STAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf) | val witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(_:squash (fact v))
: STAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
let witness
(#inames: _)
(#a: Type)
(#q: perm)
(#p: Preorder.preorder a)
(r: ref a p)
(fact: stable_property p)
(v: erased a)
(pf: squash (fact v))
= | true | null | false | coerce_atomic (witness' r fact v pf) | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.ST.GhostMonotonicReference.stable_property",
"FStar.Ghost.erased",
"Prims.squash",
"FStar.Ghost.reveal",
"Steel.ST.Coercions.coerce_atomic",
"Steel.ST.GhostMonotonicReference.witnessed",
"Steel.Effect.Common.Unobservable",
"Steel.ST.GhostMonotonicReference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.ST.GhostMonotonicReference.witness'"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(_:squash (fact v))
: STAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v) | [] | Steel.ST.GhostMonotonicReference.witness | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
r: Steel.ST.GhostMonotonicReference.ref a p ->
fact: Steel.ST.GhostMonotonicReference.stable_property p ->
v: FStar.Ghost.erased a ->
pf: Prims.squash (fact (FStar.Ghost.reveal v))
-> Steel.ST.Effect.Atomic.STAtomicUT (Steel.ST.GhostMonotonicReference.witnessed r fact) | {
"end_col": 40,
"end_line": 79,
"start_col": 4,
"start_line": 79
} |
Steel.ST.Effect.Ghost.STGhost | val write (#opened: _) (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x) | val write (#opened: _) (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
let write #opened (#a: Type) (#p: Preorder.preorder a) (#v: a) (r: ref a p) (x: a)
: STGhost unit
opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) = | true | null | false | coerce_ghost (fun _ -> MR.write r x) | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.ST.Coercions.coerce_ghost",
"Prims.unit",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.GhostMonotonicReference.pts_to_sl",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Prims.l_and",
"Prims.l_True",
"Steel.GhostMonotonicReference.write",
"Steel.ST.GhostMonotonicReference.pts_to"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val write (#opened: _) (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) | [] | Steel.ST.GhostMonotonicReference.write | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.GhostMonotonicReference.ref a p -> x: a -> Steel.ST.Effect.Ghost.STGhost Prims.unit | {
"end_col": 40,
"end_line": 48,
"start_col": 4,
"start_line": 48
} |
Steel.ST.Effect.Ghost.STGhostT | val share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v)
= coerce_ghost (fun _ -> MR.share r f v) | val share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v)
let share (#inames: _) (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a)
: STGhostT unit
inames
(pts_to r f v)
(fun _ -> (pts_to r (half_perm f) v) `star` (pts_to r (half_perm f) v)) = | true | null | false | coerce_ghost (fun _ -> MR.share r f v) | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.ST.Coercions.coerce_ghost",
"Prims.unit",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.GhostMonotonicReference.pts_to_sl",
"Steel.Effect.Common.star",
"Steel.FractionalPermission.half_perm",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.GhostMonotonicReference.share",
"Steel.ST.GhostMonotonicReference.pts_to"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf)
let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w)
let share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v) | [] | Steel.ST.GhostMonotonicReference.share | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.GhostMonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | {
"end_col": 42,
"end_line": 100,
"start_col": 4,
"start_line": 100
} |
Steel.ST.Effect.Ghost.STGhostT | val gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v)
= coerce_ghost (fun _ -> MR.gather #inames #a #p r f g v) | val gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v)
let gather (#inames: _) (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f g: perm) (v: a)
: STGhostT unit
inames
((pts_to r f v) `star` (pts_to r g v))
(fun _ -> pts_to r (sum_perm f g) v) = | true | null | false | coerce_ghost (fun _ -> MR.gather #inames #a #p r f g v) | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.ST.Coercions.coerce_ghost",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.GhostMonotonicReference.pts_to_sl",
"Steel.FractionalPermission.sum_perm",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.GhostMonotonicReference.gather",
"Steel.ST.GhostMonotonicReference.pts_to"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf)
let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:ref a p)
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w)
let share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v)
= coerce_ghost (fun _ -> MR.share r f v)
let gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v) | [] | Steel.ST.GhostMonotonicReference.gather | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
r: Steel.ST.GhostMonotonicReference.ref a p ->
f: Steel.FractionalPermission.perm ->
g: Steel.FractionalPermission.perm ->
v: a
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | {
"end_col": 59,
"end_line": 111,
"start_col": 4,
"start_line": 111
} |
Steel.ST.Effect.Ghost.STGhostT | val alloc (#opened: _) (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x | val alloc (#opened: _) (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
let alloc #opened (#a: Type) (p: Preorder.preorder a) (v: a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v) = | true | null | false | let x = coerce_ghost (fun _ -> MR.alloc p v) in
x | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.GhostMonotonicReference.ref",
"Steel.ST.Coercions.coerce_ghost",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.GhostMonotonicReference.pts_to_sl",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Prims.unit",
"Steel.GhostMonotonicReference.alloc",
"Steel.ST.GhostMonotonicReference.pts_to"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alloc (#opened: _) (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v) | [] | Steel.ST.GhostMonotonicReference.alloc | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: FStar.Preorder.preorder a -> v: a
-> Steel.ST.Effect.Ghost.STGhostT (Steel.ST.GhostMonotonicReference.ref a p) | {
"end_col": 5,
"end_line": 39,
"start_col": 3,
"start_line": 38
} |
Steel.Effect.Atomic.SteelAtomicUT | val witness':
#inames: _ ->
#a: Type ->
#q: perm ->
#p: Preorder.preorder a ->
r: ref a p ->
fact: stable_property p ->
v: erased a ->
pf: squash (fact v) ->
unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) | [
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf | val witness':
#inames: _ ->
#a: Type ->
#q: perm ->
#p: Preorder.preorder a ->
r: ref a p ->
fact: stable_property p ->
v: erased a ->
pf: squash (fact v) ->
unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v)
let witness'
(#inames: _)
(#a: Type)
(#q: perm)
(#p: Preorder.preorder a)
(r: ref a p)
(fact: stable_property p)
(v: erased a)
(pf: squash (fact v))
(_: unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) = | true | null | false | MR.witness #inames #a #q #p r fact v pf | {
"checked_file": "Steel.ST.GhostMonotonicReference.fst.checked",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostMonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostMonotonicReference.fst"
} | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"Steel.ST.GhostMonotonicReference.ref",
"Steel.ST.GhostMonotonicReference.stable_property",
"FStar.Ghost.erased",
"Prims.squash",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.GhostMonotonicReference.witness",
"Steel.GhostMonotonicReference.witnessed",
"Steel.ST.GhostMonotonicReference.witnessed",
"Steel.ST.GhostMonotonicReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | (*
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.ST.GhostMonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.GhostMonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc #opened (#a:Type) (p:Preorder.preorder a) (v:a)
: STGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
= let x = coerce_ghost (fun _ -> MR.alloc p v) in
x
let write #opened (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: STGhost unit opened
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v) | false | false | Steel.ST.GhostMonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val witness':
#inames: _ ->
#a: Type ->
#q: perm ->
#p: Preorder.preorder a ->
r: ref a p ->
fact: stable_property p ->
v: erased a ->
pf: squash (fact v) ->
unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) | [] | Steel.ST.GhostMonotonicReference.witness' | {
"file_name": "lib/steel/Steel.ST.GhostMonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
r: Steel.ST.GhostMonotonicReference.ref a p ->
fact: Steel.ST.GhostMonotonicReference.stable_property p ->
v: FStar.Ghost.erased a ->
pf: Prims.squash (fact (FStar.Ghost.reveal v)) ->
_: Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT (Steel.ST.GhostMonotonicReference.witnessed r fact) | {
"end_col": 43,
"end_line": 69,
"start_col": 4,
"start_line": 69
} |
Prims.Tot | [
{
"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
}
] | false | let state_t = seq uint8 | let state_t = | false | null | false | seq uint8 | {
"checked_file": "Spec.Frodo.Random.fst.checked",
"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"
} | [
"total"
] | [
"Lib.Sequence.seq",
"Lib.IntTypes.uint8"
] | [] | module Spec.Frodo.Random
open Lib.IntTypes
open Lib.Sequence | false | true | Spec.Frodo.Random.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_t : Type0 | [] | Spec.Frodo.Random.state_t | {
"file_name": "specs/frodo/Spec.Frodo.Random.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 23,
"end_line": 6,
"start_col": 14,
"start_line": 6
} |
|
Prims.Tot | 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)} | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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)} | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)} | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)
} | {
"end_col": 6,
"end_line": 120,
"start_col": 73,
"start_line": 117
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 4,
"end_line": 231,
"start_col": 34,
"start_line": 228
} |
Prims.Tot | 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 | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Spec.Frodo.KEM.Decaps.get_bpp_cp_matrices | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 23,
"end_line": 85,
"start_col": 54,
"start_line": 82
} |
Prims.Tot | 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) | [
{
"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
}
] | 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
//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_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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss0 | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 4,
"end_line": 138,
"start_col": 2,
"start_line": 132
} |
Prims.Pure | 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)) | [
{
"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
}
] | 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 | 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 = | false | null | false | let b1 = matrix_eq bp_matrix bpp_matrix in
let b2 = matrix_eq c_matrix cp_matrix in
logand_lemma b1 b2;
b1 &. b2 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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)) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_kp_s_cond | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 10,
"end_line": 104,
"start_col": 72,
"start_line": 100
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_seed_se_k | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 11,
"end_line": 152,
"start_col": 2,
"start_line": 148
} |
Prims.Tot | val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_bp_c_matrices:
a:frodo_alg
-> ct:lbytes (crypto_ciphertextbytes a)
-> matrix params_nbar (params_n a) & matrix params_nbar params_nbar | [] | Spec.Frodo.KEM.Decaps.get_bp_c_matrices | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 21,
"end_line": 34,
"start_col": 2,
"start_line": 29
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss2 | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 4,
"end_line": 189,
"start_col": 67,
"start_line": 186
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_mu | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 11,
"end_line": 203,
"start_col": 2,
"start_line": 200
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 4,
"end_line": 218,
"start_col": 54,
"start_line": 215
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.crypto_kem_dec_ss1 | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 4,
"end_line": 173,
"start_col": 77,
"start_line": 166
} |
Prims.Tot | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"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"
] | [] | 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) | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Spec.Frodo.KEM.Decaps.frodo_mu_decode | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) | {
"end_col": 11,
"end_line": 48,
"start_col": 50,
"start_line": 44
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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
-> 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 = | false | null | false | 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 | {
"checked_file": "Spec.Frodo.KEM.Decaps.fst.checked",
"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"
} | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Lib.ByteSequence.lbytes",
"Spec.Frodo.Params.bytes_mu",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Matrix.matrix",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Spec.Matrix.mget",
"Prims.op_Modulus",
"Spec.Frodo.Params.params_logq",
"Spec.Matrix.mod_pow2",
"Spec.Frodo.KEM.Encaps.frodo_mul_add_sb_plus_e_plus_mu",
"Spec.Frodo.KEM.Encaps.frodo_mul_add_sa_plus_e",
"Lib.IntTypes.U8",
"Spec.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.bytes_seed_a",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Spec.Frodo.Params.crypto_bytes",
"FStar.Pervasives.Native.tuple2"
] | [] | 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 | false | false | Spec.Frodo.KEM.Decaps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Spec.Frodo.KEM.Decaps.get_bpp_cp_matrices_ | {
"file_name": "specs/frodo/Spec.Frodo.KEM.Decaps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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) ->
sk: Lib.ByteSequence.lbytes (Spec.Frodo.Params.crypto_secretkeybytes a) ->
sp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
ep_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar (Spec.Frodo.Params.params_n a) ->
epp_matrix: Spec.Matrix.matrix Spec.Frodo.Params.params_nbar Spec.Frodo.Params.params_nbar
-> 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 | {
"end_col": 23,
"end_line": 71,
"start_col": 78,
"start_line": 61
} |
Prims.Tot | val check_modulus_u32:rsapss_check_modulus_st U32 | [
{
"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
}
] | false | let check_modulus_u32 : rsapss_check_modulus_st U32 =
rsapss_check_modulus check_num_bits_u32 | val check_modulus_u32:rsapss_check_modulus_st U32
let check_modulus_u32:rsapss_check_modulus_st U32 = | false | null | false | rsapss_check_modulus check_num_bits_u32 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus",
"Lib.IntTypes.U32",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u32"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_modulus_u32:rsapss_check_modulus_st U32 | [] | Hacl.Impl.RSAPSS.Keys.check_modulus_u32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st Lib.IntTypes.U32 | {
"end_col": 41,
"end_line": 142,
"start_col": 2,
"start_line": 142
} |
Prims.Tot | val check_modulus_u64:rsapss_check_modulus_st U64 | [
{
"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
}
] | false | let check_modulus_u64 : rsapss_check_modulus_st U64 =
rsapss_check_modulus check_num_bits_u64 | val check_modulus_u64:rsapss_check_modulus_st U64
let check_modulus_u64:rsapss_check_modulus_st U64 = | false | null | false | rsapss_check_modulus check_num_bits_u64 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus",
"Lib.IntTypes.U64",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u64"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_modulus_u64:rsapss_check_modulus_st U64 | [] | Hacl.Impl.RSAPSS.Keys.check_modulus_u64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st Lib.IntTypes.U64 | {
"end_col": 41,
"end_line": 161,
"start_col": 2,
"start_line": 161
} |
Prims.Tot | val check_num_bits_u32:bn_check_num_bits_st U32 | [
{
"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
}
] | false | let check_num_bits_u32 : bn_check_num_bits_st U32 =
bn_check_num_bits | val check_num_bits_u32:bn_check_num_bits_st U32
let check_num_bits_u32:bn_check_num_bits_st U32 = | false | null | false | bn_check_num_bits | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits",
"Lib.IntTypes.U32"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_num_bits_u32:bn_check_num_bits_st U32 | [] | Hacl.Impl.RSAPSS.Keys.check_num_bits_u32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st Lib.IntTypes.U32 | {
"end_col": 19,
"end_line": 139,
"start_col": 2,
"start_line": 139
} |
Prims.Tot | val check_exponent_u64:rsapss_check_exponent_st U64 | [
{
"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
}
] | false | let check_exponent_u64 : rsapss_check_exponent_st U64 =
rsapss_check_exponent check_num_bits_u64 | val check_exponent_u64:rsapss_check_exponent_st U64
let check_exponent_u64:rsapss_check_exponent_st U64 = | false | null | false | rsapss_check_exponent check_num_bits_u64 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent",
"Lib.IntTypes.U64",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u64"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_exponent_u64:rsapss_check_exponent_st U64 | [] | Hacl.Impl.RSAPSS.Keys.check_exponent_u64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st Lib.IntTypes.U64 | {
"end_col": 42,
"end_line": 164,
"start_col": 2,
"start_line": 164
} |
Prims.Tot | val check_num_bits_u64:bn_check_num_bits_st U64 | [
{
"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
}
] | false | let check_num_bits_u64 : bn_check_num_bits_st U64 =
bn_check_num_bits | val check_num_bits_u64:bn_check_num_bits_st U64
let check_num_bits_u64:bn_check_num_bits_st U64 = | false | null | false | bn_check_num_bits | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.bn_check_num_bits",
"Lib.IntTypes.U64"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_num_bits_u64:bn_check_num_bits_st U64 | [] | Hacl.Impl.RSAPSS.Keys.check_num_bits_u64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st Lib.IntTypes.U64 | {
"end_col": 19,
"end_line": 158,
"start_col": 2,
"start_line": 158
} |
Prims.Tot | val check_exponent_u32:rsapss_check_exponent_st U32 | [
{
"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
}
] | false | let check_exponent_u32 : rsapss_check_exponent_st U32 =
rsapss_check_exponent check_num_bits_u32 | val check_exponent_u32:rsapss_check_exponent_st U32
let check_exponent_u32:rsapss_check_exponent_st U32 = | false | null | false | rsapss_check_exponent check_num_bits_u32 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent",
"Lib.IntTypes.U32",
"Hacl.Impl.RSAPSS.Keys.check_num_bits_u32"
] | [] | 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] | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_exponent_u32:rsapss_check_exponent_st U32 | [] | Hacl.Impl.RSAPSS.Keys.check_exponent_u32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st Lib.IntTypes.U32 | {
"end_col": 42,
"end_line": 145,
"start_col": 2,
"start_line": 145
} |
Prims.Tot | val mk_runtime_rsapss_checks_uint64: rsapss_checks U64 | [
{
"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
}
] | false | let mk_runtime_rsapss_checks_uint64 = {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64;
} | val mk_runtime_rsapss_checks_uint64: rsapss_checks U64
let mk_runtime_rsapss_checks_uint64 = | false | null | false | {
check_num_bits = check_num_bits_u64;
check_modulus = check_modulus_u64;
check_exponent = check_exponent_u64
} | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_runtime_rsapss_checks_uint64: rsapss_checks U64 | [] | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint64 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_checks Lib.IntTypes.U64 | {
"end_col": 38,
"end_line": 172,
"start_col": 2,
"start_line": 170
} |
Prims.Tot | val mk_runtime_rsapss_checks_uint32: rsapss_checks U32 | [
{
"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
}
] | false | let mk_runtime_rsapss_checks_uint32 = {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32;
} | val mk_runtime_rsapss_checks_uint32: rsapss_checks U32
let mk_runtime_rsapss_checks_uint32 = | false | null | false | {
check_num_bits = check_num_bits_u32;
check_modulus = check_modulus_u32;
check_exponent = check_exponent_u32
} | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_runtime_rsapss_checks_uint32: rsapss_checks U32 | [] | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks_uint32 | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_checks Lib.IntTypes.U32 | {
"end_col": 38,
"end_line": 153,
"start_col": 2,
"start_line": 151
} |
Prims.Tot | val mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t | [
{
"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
}
] | 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 | val mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t
let mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t = | false | null | false | match t with
| U32 -> mk_runtime_rsapss_checks_uint32
| U64 -> mk_runtime_rsapss_checks_uint64 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_runtime_rsapss_checks (#t: limb_t) : rsapss_checks t | [] | Hacl.Impl.RSAPSS.Keys.mk_runtime_rsapss_checks | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.rsapss_checks t | {
"end_col": 42,
"end_line": 179,
"start_col": 2,
"start_line": 177
} |
Prims.Tot | [
{
"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
}
] | false | 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)) | let bn_check_num_bits_st (t: limb_t) = | false | null | false |
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)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_check_num_bits_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | [] | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> Type0 | {
"end_col": 51,
"end_line": 71,
"start_col": 4,
"start_line": 66
} |
|
Prims.Tot | [
{
"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
}
] | false | 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)) | let rsapss_check_modulus_st (t: limb_t) = | false | null | false |
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)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_check_modulus_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> Type0 | {
"end_col": 59,
"end_line": 89,
"start_col": 4,
"start_line": 84
} |
|
Prims.Tot | [
{
"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
}
] | false | 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)) | let rsapss_check_exponent_st (t: limb_t) = | false | null | false |
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)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_check_exponent_st : t: Hacl.Bignum.Definitions.limb_t -> Type0 | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> Type0 | {
"end_col": 58,
"end_line": 114,
"start_col": 4,
"start_line": 109
} |
|
Prims.Tot | val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t | [
{
"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
}
] | 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 | val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t
let bn_check_num_bits #t bs b = | false | null | false | [@@ 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": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_check_num_bits: #t:limb_t -> bn_check_num_bits_st t | [] | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t | {
"end_col": 73,
"end_line": 79,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_check_exponent:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_exponent_st t | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | bn_check_num_bits: Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t
-> Hacl.Impl.RSAPSS.Keys.rsapss_check_exponent_st t | {
"end_col": 19,
"end_line": 127,
"start_col": 56,
"start_line": 123
} |
Prims.Tot | [
{
"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
}
] | false | 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))))) | let new_rsapss_load_pkey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) = | false | null | false |
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))))) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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.pkey_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_pkey_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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val new_rsapss_load_pkey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | [] | Hacl.Impl.RSAPSS.Keys.new_rsapss_load_pkey_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | {
"end_col": 51,
"end_line": 325,
"start_col": 4,
"start_line": 303
} |
|
Prims.Tot | val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t | [
{
"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
}
] | 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) | 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 = | false | null | false | 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": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_check_modulus:
#t:limb_t
-> bn_check_num_bits:bn_check_num_bits_st t ->
rsapss_check_modulus_st t | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | bn_check_num_bits: Hacl.Impl.RSAPSS.Keys.bn_check_num_bits_st t
-> Hacl.Impl.RSAPSS.Keys.rsapss_check_modulus_st t | {
"end_col": 18,
"end_line": 104,
"start_col": 57,
"start_line": 98
} |
Prims.Tot | 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)} | [
{
"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
}
] | false | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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)} | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)} | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_pkey_len | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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)} | {
"end_col": 12,
"end_line": 41,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | [
{
"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
}
] | false | 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))))) | let new_rsapss_load_skey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) = | false | null | false |
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))))) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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
inline_for_extraction noextract | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val new_rsapss_load_skey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | [] | Hacl.Impl.RSAPSS.Keys.new_rsapss_load_skey_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | {
"end_col": 66,
"end_line": 393,
"start_col": 4,
"start_line": 367
} |
|
Prims.Tot | [
{
"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
}
] | false | 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)) | let rsapss_load_pkey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) = | false | null | false |
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)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_load_pkey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | [] | Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | {
"end_col": 98,
"end_line": 195,
"start_col": 4,
"start_line": 185
} |
|
Prims.Tot | 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)} | [
{
"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
}
] | false | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"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"
] | [] | 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)} | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)} | [] | Hacl.Impl.RSAPSS.Keys.rsapss_check_skey_len | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) } | {
"end_col": 12,
"end_line": 61,
"start_col": 2,
"start_line": 53
} |
Prims.Tot | [
{
"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
}
] | false | 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)) | let rsapss_load_skey_st (t: limb_t) (ke: BE.exp t) (modBits: size_t) = | false | null | false |
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)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Spec.RSAPSS.skey_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_skey"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_load_skey_st : t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | [] | Hacl.Impl.RSAPSS.Keys.rsapss_load_skey_st | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Bignum.Definitions.limb_t ->
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t
-> Type0 | {
"end_col": 51,
"end_line": 258,
"start_col": 4,
"start_line": 245
} |
|
Prims.Tot | 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 | [
{
"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
}
] | false | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Impl.RSAPSS.Keys.rsapss_checks",
"Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey_st",
"Hacl.Spec.RSAPSS.skey_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",
"Prims.op_AmpAmp",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Hacl.Bignum.Definitions.limb",
"Hacl.Impl.RSAPSS.Keys.__proj__Mkrsapss_checks__item__check_exponent",
"Prims.unit",
"Lib.Sequence.lemma_concat2",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.bn_from_bytes_be",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Lib.IntTypes.int_t",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.IntTypes.numbytes"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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 | [] | Hacl.Impl.RSAPSS.Keys.rsapss_load_skey | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t ->
kc: Hacl.Impl.RSAPSS.Keys.rsapss_checks t ->
rsapss_load_pkey: Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey_st t ke modBits
-> Hacl.Impl.RSAPSS.Keys.rsapss_load_skey_st t ke modBits | {
"end_col": 4,
"end_line": 298,
"start_col": 82,
"start_line": 270
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Impl.RSAPSS.Keys.rsapss_checks",
"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",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Amp_Dot",
"Prims.bool",
"Hacl.Bignum.Definitions.limb",
"Hacl.Impl.RSAPSS.Keys.__proj__Mkrsapss_checks__item__check_exponent",
"Hacl.Impl.RSAPSS.Keys.__proj__Mkrsapss_checks__item__check_modulus",
"Prims.unit",
"Lib.Sequence.lemma_concat3",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.bn_from_bytes_be",
"Hacl.Bignum.Exponentiation.__proj__Mkexp__item__precompr2",
"Lib.IntTypes.op_Subtraction_Bang",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.op_Slash_Dot",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.IntTypes.numbytes"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_load_pkey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
rsapss_load_pkey_st t ke modBits | [] | Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t ->
kc: Hacl.Impl.RSAPSS.Keys.rsapss_checks t
-> Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey_st t ke modBits | {
"end_col": 29,
"end_line": 237,
"start_col": 56,
"start_line": 206
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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 | 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 = | false | null | false | [@@ 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
(let open B in 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
(let open B in 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
(B.free (pkey <: buffer (limb t));
B.null) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Impl.RSAPSS.Keys.rsapss_checks",
"FStar.Monotonic.HyperHeap.rid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Definitions.blocks0",
"FStar.UInt32.__uint_to_t",
"Prims.op_Negation",
"Hacl.Impl.RSAPSS.Keys.rsapss_check_pkey_len",
"LowStar.Buffer.null",
"Hacl.Bignum.Definitions.limb",
"LowStar.Buffer.buffer",
"Prims.bool",
"Prims.unit",
"LowStar.Monotonic.Buffer.free",
"LowStar.Buffer.trivial_preorder",
"Lib.Buffer.buffer",
"Hacl.Spec.RSAPSS.rsapss_load_pkey_lemma",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"LowStar.Monotonic.Buffer.modifies_only_not_unused_in",
"LowStar.Monotonic.Buffer.loc_none",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey",
"Hacl.Bignum.Definitions.lbignum",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Lib.Buffer.buffer_t",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.len",
"LowStar.Monotonic.Buffer.is_null",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.l_imp",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.l_and",
"Prims.nat",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable",
"LowStar.Monotonic.Buffer.mmalloc_partial",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"LowStar.Monotonic.Buffer.lmbuffer_or_null",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.bits"
] | [] | 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 | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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 | [] | Hacl.Impl.RSAPSS.Keys.new_rsapss_load_pkey | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t ->
kc: Hacl.Impl.RSAPSS.Keys.rsapss_checks t
-> Hacl.Impl.RSAPSS.Keys.new_rsapss_load_pkey_st t ke modBits | {
"end_col": 18,
"end_line": 362,
"start_col": 2,
"start_line": 337
} |
Prims.Tot | val new_rsapss_load_skey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
new_rsapss_load_skey_st t ke modBits | [
{
"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
}
] | false | let new_rsapss_load_skey #t ke modBits kc r eBits dBits nb eb db =
[@inline_let] let bits = size (bits t) in
if not (rsapss_check_skey_len #t modBits eBits dBits) then
B.null
else begin
assert (LS.skey_len_pre t (v modBits) (v eBits) (v dBits));
let h0 = ST.get () 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
let skey = LowStar.Monotonic.Buffer.mmalloc_partial r (uint #t 0) skeyLen in
if B.is_null skey then
skey
else
let h1 = ST.get () in
B.(modifies_only_not_unused_in loc_none h0 h1);
assert (B.len skey == skeyLen);
let skey: Lib.Buffer.buffer (limb t) = skey in
assert (B.length skey == FStar.UInt32.v skeyLen);
let skey: lbignum t skeyLen = skey in
let b = rsapss_load_skey ke modBits kc (rsapss_load_pkey ke modBits kc) eBits dBits nb eb db skey in
let h2 = ST.get () in
B.(modifies_only_not_unused_in loc_none h0 h2);
LS.rsapss_load_skey_lemma #t (v modBits) (v eBits) (v dBits)
(as_seq h0 nb) (as_seq h0 eb) (as_seq h0 db);
if b then skey else begin
B.free (skey <: buffer (limb t));
B.null end
end | val new_rsapss_load_skey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
new_rsapss_load_skey_st t ke modBits
let new_rsapss_load_skey #t ke modBits kc r eBits dBits nb eb db = | false | null | false | [@@ inline_let ]let bits = size (bits t) in
if not (rsapss_check_skey_len #t modBits eBits dBits)
then B.null
else
(assert (LS.skey_len_pre t (v modBits) (v eBits) (v dBits));
let h0 = ST.get () 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
let skey = LowStar.Monotonic.Buffer.mmalloc_partial r (uint #t 0) skeyLen in
if B.is_null skey
then skey
else
let h1 = ST.get () in
(let open B in modifies_only_not_unused_in loc_none h0 h1);
assert (B.len skey == skeyLen);
let skey:Lib.Buffer.buffer (limb t) = skey in
assert (B.length skey == FStar.UInt32.v skeyLen);
let skey:lbignum t skeyLen = skey in
let b =
rsapss_load_skey ke modBits kc (rsapss_load_pkey ke modBits kc) eBits dBits nb eb db skey
in
let h2 = ST.get () in
(let open B in modifies_only_not_unused_in loc_none h0 h2);
LS.rsapss_load_skey_lemma #t
(v modBits)
(v eBits)
(v dBits)
(as_seq h0 nb)
(as_seq h0 eb)
(as_seq h0 db);
if b
then skey
else
(B.free (skey <: buffer (limb t));
B.null)) | {
"checked_file": "Hacl.Impl.RSAPSS.Keys.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Exponentiation.exp",
"Lib.IntTypes.size_t",
"Hacl.Impl.RSAPSS.Keys.rsapss_checks",
"FStar.Monotonic.HyperHeap.rid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Definitions.blocks0",
"FStar.UInt32.__uint_to_t",
"Prims.op_Negation",
"Hacl.Impl.RSAPSS.Keys.rsapss_check_skey_len",
"LowStar.Buffer.null",
"Hacl.Bignum.Definitions.limb",
"LowStar.Buffer.buffer",
"Prims.bool",
"Prims.unit",
"LowStar.Monotonic.Buffer.free",
"LowStar.Buffer.trivial_preorder",
"Lib.Buffer.buffer",
"Hacl.Spec.RSAPSS.rsapss_load_skey_lemma",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"LowStar.Monotonic.Buffer.modifies_only_not_unused_in",
"LowStar.Monotonic.Buffer.loc_none",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.RSAPSS.Keys.rsapss_load_skey",
"Hacl.Impl.RSAPSS.Keys.rsapss_load_pkey",
"Hacl.Bignum.Definitions.lbignum",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Lib.Buffer.buffer_t",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.len",
"LowStar.Monotonic.Buffer.is_null",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.l_imp",
"LowStar.Monotonic.Buffer.g_is_null",
"Prims.l_and",
"Prims.nat",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable",
"LowStar.Monotonic.Buffer.mmalloc_partial",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"LowStar.Monotonic.Buffer.lmbuffer_or_null",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Bignum.Definitions.blocks",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.IntTypes.size",
"Lib.IntTypes.bits"
] | [] | 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
inline_for_extraction noextract
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)))))
#set-options "--z3rlimit 100"
inline_for_extraction noextract
val new_rsapss_load_skey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
new_rsapss_load_skey_st t ke modBits | false | false | Hacl.Impl.RSAPSS.Keys.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val new_rsapss_load_skey:
#t:limb_t
-> ke:BE.exp t
-> modBits:size_t
-> kc:rsapss_checks t ->
new_rsapss_load_skey_st t ke modBits | [] | Hacl.Impl.RSAPSS.Keys.new_rsapss_load_skey | {
"file_name": "code/rsapss/Hacl.Impl.RSAPSS.Keys.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ke: Hacl.Bignum.Exponentiation.exp t ->
modBits: Lib.IntTypes.size_t ->
kc: Hacl.Impl.RSAPSS.Keys.rsapss_checks t
-> Hacl.Impl.RSAPSS.Keys.new_rsapss_load_skey_st t ke modBits | {
"end_col": 5,
"end_line": 436,
"start_col": 2,
"start_line": 407
} |
Prims.Tot | val va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Paddd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Paddd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 10,
"end_line": 88,
"start_col": 2,
"start_line": 84
} |
Prims.Tot | val va_wp_Pand
(dst: va_operand_xmm)
(src: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pand
(dst: va_operand_xmm)
(src: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pand | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 76,
"end_line": 193,
"start_col": 2,
"start_line": 189
} |
Prims.Tot | val va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pxor (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pxor | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 36,
"end_line": 158,
"start_col": 2,
"start_line": 155
} |
Prims.Tot | val va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Palignr8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Palignr8 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 94,
"end_line": 375,
"start_col": 2,
"start_line": 369
} |
Prims.Tot | val va_wp_Pslld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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)) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pslld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pslld | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 92,
"end_line": 263,
"start_col": 2,
"start_line": 260
} |
Prims.Tot | val va_wp_VPxor
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPxor
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VPxor | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 78,
"end_line": 229,
"start_col": 2,
"start_line": 226
} |
Prims.Tot | val va_wp_Psrld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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)) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Psrld
(dst: va_operand_xmm)
(amt: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Psrld | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 92,
"end_line": 296,
"start_col": 2,
"start_line": 293
} |
Prims.Tot | val va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Palignr4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Palignr4 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 94,
"end_line": 335,
"start_col": 2,
"start_line": 329
} |
Prims.Tot | val va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPshufb
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VPshufb | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 88,
"end_line": 605,
"start_col": 2,
"start_line": 600
} |
Prims.Tot | val va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_PshufbDup (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_PshufbDup | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 38,
"end_line": 702,
"start_col": 2,
"start_line": 692
} |
Prims.Tot | val va_wp_Shufpd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Shufpd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Shufpd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 10,
"end_line": 473,
"start_col": 2,
"start_line": 460
} |
Prims.Tot | val va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPslldq4 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VPslldq4 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 94,
"end_line": 1076,
"start_col": 2,
"start_line": 1071
} |
Prims.Tot | val va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Mov128 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Mov128 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 75,
"end_line": 1180,
"start_col": 2,
"start_line": 1178
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pextrq
(dst: va_operand_dst_opr64)
(src: va_operand_xmm)
(index: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pextrq | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 31,
"end_line": 886,
"start_col": 2,
"start_line": 882
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Load128_buffer
(h: va_operand_heaplet)
(dst: va_operand_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 | [] | Vale.X64.InsVector.va_wp_Load128_buffer | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 21,
"end_line": 1230,
"start_col": 2,
"start_line": 1221
} |
Prims.Tot | val va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vpslldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Vpslldq8 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 94,
"end_line": 1112,
"start_col": 2,
"start_line": 1108
} |
Prims.Tot | val va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Vpsrldq8 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Vpsrldq8 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 98,
"end_line": 1148,
"start_col": 2,
"start_line": 1144
} |
Prims.Tot | val va_wp_InitPshufbMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_InitPshufbMask (dst:va_operand_xmm) (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 /\
(forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (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.Words_s.Mkfour
#Vale.Def.Types_s.nat32 202182159 134810123 67438087 66051 ==> va_k va_sM (()))) | val va_wp_InitPshufbMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_InitPshufbMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_tmp: va_value_reg_opr64) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(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.Words_s.Mkfour #Vale.Def.Types_s.nat32 202182159 134810123 67438087 66051 ==>
va_k va_sM (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_reg_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_dst_reg_opr64",
"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.Decls.va_value_reg_opr64",
"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_reg_opr64",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | 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)))))
[@ va_qattr]
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 (())))
val va_wpProof_ZeroXmm : dst:va_operand_xmm -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_ZeroXmm dst va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_ZeroXmm dst) ([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_ZeroXmm (dst:va_operand_xmm) : (va_quickCode unit (va_code_ZeroXmm dst)) =
(va_QProc (va_code_ZeroXmm dst) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_ZeroXmm dst)
(va_wpProof_ZeroXmm dst))
//--
//-- InitPshufbMask
val va_code_InitPshufbMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_InitPshufbMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot
va_pbool
val va_lemma_InitPshufbMask : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_InitPshufbMask dst 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))
(ensures (fun (va_sM, va_fM) -> va_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 202182159 134810123
67438087 66051 /\ va_state_eq va_sM (va_update_flags 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_InitPshufbMask (dst:va_operand_xmm) (tmp:va_operand_reg_opr64) (va_s0:va_state) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_InitPshufbMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_InitPshufbMask | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
tmp: Vale.X64.Decls.va_operand_reg_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 84,
"end_line": 1471,
"start_col": 2,
"start_line": 1467
} |
Prims.Tot | val va_wp_InitPshufbStableMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | let va_wp_InitPshufbStableMask (dst:va_operand_xmm) (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 /\
(forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (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.Words_s.Mkfour
#Vale.Def.Types_s.nat32 66051 67438087 134810123 202182159 ==> va_k va_sM (()))) | val va_wp_InitPshufbStableMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_InitPshufbStableMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_dst_reg_opr64 tmp va_s0 /\ va_get_ok va_s0 /\ sse_enabled /\
(forall (va_x_dst: va_value_xmm) (va_x_tmp: va_value_reg_opr64) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(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.Words_s.Mkfour #Vale.Def.Types_s.nat32 66051 67438087 134810123 202182159 ==>
va_k va_sM (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_reg_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_dst_reg_opr64",
"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.Decls.va_value_reg_opr64",
"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_reg_opr64",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | 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)))))
[@ va_qattr]
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 (())))
val va_wpProof_ZeroXmm : dst:va_operand_xmm -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_ZeroXmm dst va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_ZeroXmm dst) ([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_ZeroXmm (dst:va_operand_xmm) : (va_quickCode unit (va_code_ZeroXmm dst)) =
(va_QProc (va_code_ZeroXmm dst) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_ZeroXmm dst)
(va_wpProof_ZeroXmm dst))
//--
//-- InitPshufbMask
val va_code_InitPshufbMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_InitPshufbMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot
va_pbool
val va_lemma_InitPshufbMask : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_InitPshufbMask dst 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))
(ensures (fun (va_sM, va_fM) -> va_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 202182159 134810123
67438087 66051 /\ va_state_eq va_sM (va_update_flags 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_InitPshufbMask (dst:va_operand_xmm) (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 /\
(forall (va_x_dst:va_value_xmm) (va_x_tmp:va_value_reg_opr64) (va_x_efl:Vale.X64.Flags.t) . let
va_sM = va_upd_flags va_x_efl (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.Words_s.Mkfour
#Vale.Def.Types_s.nat32 202182159 134810123 67438087 66051 ==> va_k va_sM (())))
val va_wpProof_InitPshufbMask : dst:va_operand_xmm -> 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_InitPshufbMask dst tmp va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_InitPshufbMask dst tmp)
([va_Mod_flags; 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_InitPshufbMask (dst:va_operand_xmm) (tmp:va_operand_reg_opr64) : (va_quickCode unit
(va_code_InitPshufbMask dst tmp)) =
(va_QProc (va_code_InitPshufbMask dst tmp) ([va_Mod_flags; va_mod_reg_opr64 tmp; va_mod_xmm dst])
(va_wp_InitPshufbMask dst tmp) (va_wpProof_InitPshufbMask dst tmp))
//--
//-- InitPshufbStableMask
val va_code_InitPshufbStableMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot va_code
val va_codegen_success_InitPshufbStableMask : dst:va_operand_xmm -> tmp:va_operand_reg_opr64 -> Tot
va_pbool
val va_lemma_InitPshufbStableMask : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
tmp:va_operand_reg_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_InitPshufbStableMask dst 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))
(ensures (fun (va_sM, va_fM) -> va_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 66051 67438087
134810123 202182159 /\ va_state_eq va_sM (va_update_flags 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_InitPshufbStableMask (dst:va_operand_xmm) (tmp:va_operand_reg_opr64) (va_s0:va_state) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_InitPshufbStableMask
(dst: va_operand_xmm)
(tmp: va_operand_reg_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_InitPshufbStableMask | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
tmp: Vale.X64.Decls.va_operand_reg_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 84,
"end_line": 1508,
"start_col": 2,
"start_line": 1504
} |
Prims.Tot | val va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPaddd
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VPaddd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 37,
"end_line": 125,
"start_col": 2,
"start_line": 121
} |
Prims.Tot | val va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPalignr8
(dst src1 src2: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VPalignr8 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 95,
"end_line": 420,
"start_col": 2,
"start_line": 413
} |
Prims.Tot | val va_wp_VShufpd
(dst src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VShufpd
(dst src1 src2: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_VShufpd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 95,
"end_line": 528,
"start_col": 2,
"start_line": 515
} |
Prims.Tot | val va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pshufb (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pshufb | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 100,
"end_line": 564,
"start_col": 2,
"start_line": 560
} |
Prims.Tot | val va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_PshufbStable
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_PshufbStable | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 49,
"end_line": 655,
"start_col": 2,
"start_line": 644
} |
Prims.Tot | val va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 -> | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pshufb64 (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pshufb64 | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 38,
"end_line": 749,
"start_col": 2,
"start_line": 739
} |
Prims.Tot | val va_wp_Pshufd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"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
}
] | false | 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_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 src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Pshufd
(dst src: va_operand_xmm)
(permutation: nat8)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.InsVector.va_wp_Pshufd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 25,
"end_line": 800,
"start_col": 2,
"start_line": 789
} |
Prims.Ghost | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | [
{
"abbrev": false,
"full_module": "Vale.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
}
] | false | let buffer128_write (b:buffer128) (i:int) (v:quad32) (h:vale_heap) : Ghost vale_heap
(requires buffer_readable h b /\ buffer_writeable b)
(ensures fun _ -> True)
=
buffer_write b i v h | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True)
let buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) = | false | null | false | buffer_write b i v h | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val buffer128_write (b: buffer128) (i: int) (v: quad32) (h: vale_heap)
: Ghost vale_heap (requires buffer_readable h b /\ buffer_writeable b) (ensures fun _ -> True) | [] | Vale.X64.InsVector.buffer128_write | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 22,
"end_line": 25,
"start_col": 2,
"start_line": 25
} |
Prims.Tot | val va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) | [
{
"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
}
] | false | 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)) | val va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src))
let va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) = | false | null | false | (va_QProc (va_code_Paddd dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_Paddd dst src)
(va_wpProof_Paddd dst src)) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Paddd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_Paddd dst src)) | [] | Vale.X64.InsVector.va_quick_Paddd | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | 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) | {
"end_col": 31,
"end_line": 100,
"start_col": 2,
"start_line": 99
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | (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 (()))) | {
"checked_file": "Vale.X64.InsVector.fsti.checked",
"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"
} | [
"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"
] | [] | 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) | false | true | Vale.X64.InsVector.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_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 | [] | Vale.X64.InsVector.va_wp_Mem128_lemma | {
"file_name": "obj/Vale.X64.InsVector.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 63,
"end_line": 53,
"start_col": 2,
"start_line": 47
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.