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 listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 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 listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.HyperStack.ST.Stack | val fmul_rn:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
(let rn = gsub precomp 10ul 5ul in
let rn_5 = gsub precomp 15ul 5ul in
felem_fits h f1 (3, 3, 3, 3, 3) /\
felem_fits h rn (2, 2, ... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": tru... | false | let fmul_rn #s out f1 precomp =
match s with
| M32 -> F32xN.fmul_rn #1 out f1 precomp
| M128 -> F32xN.fmul_rn #2 out f1 precomp
| M256 -> F32xN.fmul_rn #4 out f1 precomp | val fmul_rn:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
(let rn = gsub precomp 10ul 5ul in
let rn_5 = gsub precomp 15ul 5ul in
felem_fits h f1 (3, 3, 3, 3, 3) /\
felem_fits h rn (2, 2, ... | true | null | false | match s with
| M32 -> F32xN.fmul_rn #1 out f1 precomp
| M128 -> F32xN.fmul_rn #2 out f1 precomp
| M256 -> F32xN.fmul_rn #4 out f1 precomp | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"... | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Fields.precomp_r",
"Hacl.Impl.Poly1305.Field32xN.fmul_rn",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module ... | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_el... | null | val fmul_rn:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
(let rn = gsub precomp 10ul 5ul in
let rn_5 = gsub precomp 15ul 5ul in
felem_fits h f1 (3, 3, 3, 3, 3) /\
felem_fits h rn (2, 2, ... | [] | Hacl.Impl.Poly1305.Fields.fmul_rn | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Impl.Poly1305.Fields.felem s ->
f1: Hacl.Impl.Poly1305.Fields.felem s ->
precomp: Hacl.Impl.Poly1305.Fields.precomp_r s
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 43,
"end_line": 356,
"start_col": 2,
"start_line": 353
} |
FStar.HyperStack.ST.Stack | val fadd_mul_r:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
F32xN.fmul_precomp_r_pre #(width s) h precomp /\
felem_fits h out (2, 2, 2, 2, 2) /\
felem_fits h f1 (1, 1, 1, 1, 1))
(ensures ... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": tru... | false | let fadd_mul_r #s out f1 precomp =
match s with
| M32 -> F32xN.fadd_mul_r #1 out f1 precomp
| M128 -> F32xN.fadd_mul_r #2 out f1 precomp
| M256 -> F32xN.fadd_mul_r #4 out f1 precomp | val fadd_mul_r:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
F32xN.fmul_precomp_r_pre #(width s) h precomp /\
felem_fits h out (2, 2, 2, 2, 2) /\
felem_fits h f1 (1, 1, 1, 1, 1))
(ensures ... | true | null | false | match s with
| M32 -> F32xN.fadd_mul_r #1 out f1 precomp
| M128 -> F32xN.fadd_mul_r #2 out f1 precomp
| M256 -> F32xN.fadd_mul_r #4 out f1 precomp | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"... | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Fields.precomp_r",
"Hacl.Impl.Poly1305.Field32xN.fadd_mul_r",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module ... | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_el... | null | val fadd_mul_r:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
F32xN.fmul_precomp_r_pre #(width s) h precomp /\
felem_fits h out (2, 2, 2, 2, 2) /\
felem_fits h f1 (1, 1, 1, 1, 1))
(ensures ... | [] | Hacl.Impl.Poly1305.Fields.fadd_mul_r | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Impl.Poly1305.Fields.felem s ->
f1: Hacl.Impl.Poly1305.Fields.felem s ->
precomp: Hacl.Impl.Poly1305.Fields.precomp_r s
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 46,
"end_line": 329,
"start_col": 2,
"start_line": 326
} |
FStar.HyperStack.ST.Stack | val fmul_rn_normalize:
#s:field_spec
-> out:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h precomp /\
felem_fits h out (3, 3, 3, 3, 3) /\
F32xN.load_precompute_r_post #(width s) h precomp)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_f... | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": tru... | false | let fmul_rn_normalize #s out precomp =
match s with
| M32 -> Field32xN_32.fmul_r1_normalize out precomp
| M128 -> Field32xN_128.fmul_r2_normalize out precomp
| M256 -> Field32xN_256.fmul_r4_normalize out precomp | val fmul_rn_normalize:
#s:field_spec
-> out:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h precomp /\
felem_fits h out (3, 3, 3, 3, 3) /\
F32xN.load_precompute_r_post #(width s) h precomp)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_f... | true | null | false | match s with
| M32 -> Field32xN_32.fmul_r1_normalize out precomp
| M128 -> Field32xN_128.fmul_r2_normalize out precomp
| M256 -> Field32xN_256.fmul_r4_normalize out precomp | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"... | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Fields.precomp_r",
"Hacl.Impl.Poly1305.Field32xN_32.fmul_r1_normalize",
"Prims.unit",
"Hacl.Impl.Poly1305.Field32xN_128.fmul_r2_normalize",
"Hacl.Impl.Poly1305.Field32xN_256.fmul_r4_normalize"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module ... | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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_el... | null | val fmul_rn_normalize:
#s:field_spec
-> out:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h precomp /\
felem_fits h out (3, 3, 3, 3, 3) /\
F32xN.load_precompute_r_post #(width s) h precomp)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_f... | [] | Hacl.Impl.Poly1305.Fields.fmul_rn_normalize | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | out: Hacl.Impl.Poly1305.Fields.felem s -> precomp: Hacl.Impl.Poly1305.Fields.precomp_r s
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 55,
"end_line": 379,
"start_col": 2,
"start_line": 376
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "EverParse3d.Prelude",
"short_module": null
},
{
"abbrev": true,
"full_module"... | false | let is_range_okay = EverParse3d.ErrorCode.is_range_okay | let is_range_okay = | false | null | false | EverParse3d.ErrorCode.is_range_okay | {
"checked_file": "EverParse3d.Actions.Base.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"EverParse3d.Prelude.fsti.checked",
"EverParse3d.ErrorCode.fst.checke... | [
"total"
] | [
"EverParse3d.ErrorCode.is_range_okay"
] | [] | (*
Copyright 2019 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... | false | true | EverParse3d.Actions.Base.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val is_range_okay : size: FStar.UInt32.t -> offset: FStar.UInt32.t -> access_size: FStar.UInt32.t -> Prims.bool | [] | EverParse3d.Actions.Base.is_range_okay | {
"file_name": "src/3d/prelude/EverParse3d.Actions.Base.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | size: FStar.UInt32.t -> offset: FStar.UInt32.t -> access_size: FStar.UInt32.t -> Prims.bool | {
"end_col": 55,
"end_line": 27,
"start_col": 20,
"start_line": 27
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "EverParse3d.Prelude",
"short_module": null
},
{
"abbrev": true,
"full_module"... | false | let validator #nz #wk (#k:parser_kind nz wk) (#t:Type) (p:parser k t)
= validate_with_action_t p true_inv eloc_none true | let validator #nz #wk (#k: parser_kind nz wk) (#t: Type) (p: parser k t) = | false | null | false | validate_with_action_t p true_inv eloc_none true | {
"checked_file": "EverParse3d.Actions.Base.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"EverParse3d.Prelude.fsti.checked",
"EverParse3d.ErrorCode.fst.checke... | [
"total"
] | [
"Prims.bool",
"EverParse3d.Kinds.weak_kind",
"EverParse3d.Kinds.parser_kind",
"EverParse3d.Prelude.parser",
"EverParse3d.Actions.Base.validate_with_action_t",
"EverParse3d.Actions.Base.true_inv",
"EverParse3d.Actions.Base.eloc_none"
] | [] | (*
Copyright 2019 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... | false | false | EverParse3d.Actions.Base.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val validator : p: EverParse3d.Prelude.parser k t -> Type0 | [] | EverParse3d.Actions.Base.validator | {
"file_name": "src/3d/prelude/EverParse3d.Actions.Base.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: EverParse3d.Prelude.parser k t -> Type0 | {
"end_col": 52,
"end_line": 502,
"start_col": 4,
"start_line": 502
} | |
Prims.Tot | val pad (a: md_alg) (total_len: nat{total_len `less_than_max_input_length` a})
: Tot (b: bytes{(S.length b + total_len) % block_length a = 0}) | [
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_m... | false | let pad (a:md_alg)
(total_len:nat{total_len `less_than_max_input_length` a}):
Tot (b:bytes{(S.length b + total_len) % block_length a = 0})
= let open FStar.Mul in
let firstbyte = S.create 1 (u8 0x80) in
let zeros = S.create (pad0_length a total_len) (u8 0) in
let total_len_bits = total_len * 8 in
... | val pad (a: md_alg) (total_len: nat{total_len `less_than_max_input_length` a})
: Tot (b: bytes{(S.length b + total_len) % block_length a = 0})
let pad (a: md_alg) (total_len: nat{total_len `less_than_max_input_length` a})
: Tot (b: bytes{(S.length b + total_len) % block_length a = 0}) = | false | null | false | let open FStar.Mul in
let firstbyte = S.create 1 (u8 0x80) in
let zeros = S.create (pad0_length a total_len) (u8 0) in
let total_len_bits = total_len * 8 in
max_input_size_len a;
let encodedlen:lbytes (len_length a) =
match a with
| MD5 -> Lib.ByteSequence.uint_to_bytes_le (secret (nat_to_len a (total_len * 8)))
... | {
"checked_file": "Spec.Hash.MD.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file... | [
"total"
] | [
"Spec.Hash.Definitions.md_alg",
"Prims.nat",
"Prims.b2t",
"Spec.Hash.Definitions.less_than_max_input_length",
"FStar.Seq.Base.op_At_Bar",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.lseq",
"Spec.Hash.Definitions.len_length",
"Lib.ByteSequence.uint_to_bytes_le",
"... | [] | module Spec.Hash.MD
module S = FStar.Seq
open Lib.IntTypes
open Lib.ByteSequence
open Spec.Hash.Definitions
(** This module contains a Merkle-Damgard padding scheme for the
MD hashes ONLY (md5, sha1, sha2)
In Spec.Agile.Hash, the one-shot hash for MD hashes is defined pad,
update_multi, finish.
*)
#push-opti... | false | false | Spec.Hash.MD.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_el... | null | val pad (a: md_alg) (total_len: nat{total_len `less_than_max_input_length` a})
: Tot (b: bytes{(S.length b + total_len) % block_length a = 0}) | [] | Spec.Hash.MD.pad | {
"file_name": "specs/Spec.Hash.MD.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.md_alg ->
total_len: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length total_len a}
-> b:
Spec.Hash.Definitions.bytes
{(FStar.Seq.Base.length b + total_len) % Spec.Hash.Definitions.block_length a = 0} | {
"end_col": 40,
"end_line": 43,
"start_col": 4,
"start_line": 32
} |
FStar.Pervasives.Lemma | val max_input_size_len (a: hash_alg{is_md a})
: Lemma (ensures FStar.Mul.(Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8))) | [
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_m... | false | let max_input_size_len (a: hash_alg{is_md a}): Lemma
(ensures FStar.Mul.(Some ?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8)))
=
let open FStar.Mul in
assert_norm (Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8)) | val max_input_size_len (a: hash_alg{is_md a})
: Lemma (ensures FStar.Mul.(Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8)))
let max_input_size_len (a: hash_alg{is_md a})
: Lemma (ensures FStar.Mul.(Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8))) = | false | null | true | let open FStar.Mul in assert_norm (Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8)) | {
"checked_file": "Spec.Hash.MD.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file... | [
"lemma"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.Hash.Definitions.is_md",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.pos",
"Spec.Hash.Definitions.max_input_length",
"Pri... | [] | module Spec.Hash.MD
module S = FStar.Seq
open Lib.IntTypes
open Lib.ByteSequence
open Spec.Hash.Definitions
(** This module contains a Merkle-Damgard padding scheme for the
MD hashes ONLY (md5, sha1, sha2)
In Spec.Agile.Hash, the one-shot hash for MD hashes is defined pad,
update_multi, finish.
*)
#push-opti... | false | false | Spec.Hash.MD.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"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_el... | null | val max_input_size_len (a: hash_alg{is_md a})
: Lemma (ensures FStar.Mul.(Some?.v (max_input_length a) * 8 + 8 = pow2 (len_length a * 8))) | [] | Spec.Hash.MD.max_input_size_len | {
"file_name": "specs/Spec.Hash.MD.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.hash_alg{Spec.Hash.Definitions.is_md a}
-> FStar.Pervasives.Lemma
(ensures
Some?.v (Spec.Hash.Definitions.max_input_length a) * 8 + 8 =
Prims.pow2 (Spec.Hash.Definitions.len_length a * 8)) | {
"end_col": 78,
"end_line": 22,
"start_col": 2,
"start_line": 21
} |
FStar.HyperStack.ST.Stack | val clear_words_u8:
#len:size_t
-> b:lbytes len
-> Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1) | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Memzero0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "L... | false | let clear_words_u8 #len b =
memzero #uint8 b len | val clear_words_u8:
#len:size_t
-> b:lbytes len
-> Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1)
let clear_words_u8 #len b = | true | null | false | memzero #uint8 b len | {
"checked_file": "Hacl.Impl.Frodo.KEM.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Memzero0.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [] | [
"Lib.IntTypes.size_t",
"Hacl.Impl.Matrix.lbytes",
"Lib.Memzero0.memzero",
"Lib.IntTypes.uint8",
"Prims.unit"
] | [] | module Hacl.Impl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.Memzero0
open Hacl.Impl.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val clear_matrix:
#n1:size_t
-> #n2:size_t{v ... | false | false | Hacl.Impl.Frodo.KEM.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_el... | null | val clear_words_u8:
#len:size_t
-> b:lbytes len
-> Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1) | [] | Hacl.Impl.Frodo.KEM.clear_words_u8 | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Hacl.Impl.Matrix.lbytes len -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 22,
"end_line": 39,
"start_col": 2,
"start_line": 39
} |
FStar.HyperStack.ST.Stack | val clear_matrix:
#n1:size_t
-> #n2:size_t{v n1 * v n2 <= max_size_t}
-> m:matrix_t n1 n2
-> Stack unit
(requires fun h -> live h m)
(ensures fun h0 _ h1 -> modifies1 m h0 h1) | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Memzero0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "L... | false | let clear_matrix #n1 #n2 m =
memzero #uint16 m (n1 *! n2) | val clear_matrix:
#n1:size_t
-> #n2:size_t{v n1 * v n2 <= max_size_t}
-> m:matrix_t n1 n2
-> Stack unit
(requires fun h -> live h m)
(ensures fun h0 _ h1 -> modifies1 m h0 h1)
let clear_matrix #n1 #n2 m = | true | null | false | memzero #uint16 m (n1 *! n2) | {
"checked_file": "Hacl.Impl.Frodo.KEM.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Memzero0.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Hacl.Impl.Matrix.matrix_t",
"Lib.Memzero0.memzero",
"Lib.IntTypes.uint16",
"Lib.IntTypes.op_Star_Bang",
"Prims.unit"
] | [] | module Hacl.Impl.Frodo.KEM
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.Memzero0
open Hacl.Impl.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val clear_matrix:
#n1:size_t
-> #n2:size_t{v ... | false | false | Hacl.Impl.Frodo.KEM.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_el... | null | val clear_matrix:
#n1:size_t
-> #n2:size_t{v n1 * v n2 <= max_size_t}
-> m:matrix_t n1 n2
-> Stack unit
(requires fun h -> live h m)
(ensures fun h0 _ h1 -> modifies1 m h0 h1) | [] | Hacl.Impl.Frodo.KEM.clear_matrix | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Hacl.Impl.Matrix.matrix_t n1 n2 -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 30,
"end_line": 27,
"start_col": 2,
"start_line": 27
} |
Prims.Tot | val write_exchange_allowed (w1 w2: locations) (c1 c2: locations_with_values) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let write_exchange_allowed (w1 w2:locations) (c1 c2:locations_with_values) : pbool =
write_same_constants c1 c2 &&.
for_all (aux_write_exchange_allowed w2 c1 c2) w1 &&.
(* REVIEW: Just to make the symmetry proof easier, we write the
other way around too. However, this makes things not as fast as
they _c... | val write_exchange_allowed (w1 w2: locations) (c1 c2: locations_with_values) : pbool
let write_exchange_allowed (w1 w2: locations) (c1 c2: locations_with_values) : pbool = | false | null | false | write_same_constants c1 c2 &&. for_all (aux_write_exchange_allowed w2 c1 c2) w1 &&.
for_all (aux_write_exchange_allowed w1 c2 c1) w2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Def.PossiblyMonad.op_Amp_Amp_Dot",
"Vale.Transformers.InstructionReorder.write_same_constants",
"Vale.Def.PossiblyMonad.for_all",
"Vale.Transformers.Locations.location",
"Vale.Transformers... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val write_exchange_allowed (w1 w2: locations) (c1 c2: locations_with_values) : pbool | [] | Vale.Transformers.InstructionReorder.write_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w1: Vale.Transformers.Locations.locations ->
w2: Vale.Transformers.Locations.locations ->
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 50,
"end_line": 87,
"start_col": 2,
"start_line": 82
} |
Prims.GTot | val equiv_states_ext (s1 s2: machine_state) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let equiv_states_ext (s1 s2 : machine_state) : GTot Type0 =
let open FStar.FunctionalExtensionality in
(feq s1.ms_regs s2.ms_regs) /\
(s1.ms_heap == s2.ms_heap) /\
(Map.equal s1.ms_stack.stack_mem s2.ms_stack.stack_mem) /\
(Map.equal s1.ms_stackTaint s2.ms_stackTaint) /\
(equiv_states s1 s2) | val equiv_states_ext (s1 s2: machine_state) : GTot Type0
let equiv_states_ext (s1 s2: machine_state) : GTot Type0 = | false | null | false | let open FStar.FunctionalExtensionality in
(feq s1.ms_regs s2.ms_regs) /\ (s1.ms_heap == s2.ms_heap) /\
(Map.equal s1.ms_stack.stack_mem s2.ms_stack.stack_mem) /\
(Map.equal s1.ms_stackTaint s2.ms_stackTaint) /\ (equiv_states s1 s2) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"sometrivial"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_and",
"FStar.FunctionalExtensionality.feq",
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Prims.eq2",
"Vale.Arch.Heap.heap_impl",
"Vale.X64.Machine_Semantics_s.__pro... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val equiv_states_ext (s1 s2: machine_state) : GTot Type0 | [] | Vale.Transformers.InstructionReorder.equiv_states_ext | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.X64.Machine_Semantics_s.machine_state -> s2: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.GTot Type0 | {
"end_col": 22,
"end_line": 155,
"start_col": 2,
"start_line": 150
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let filt_state (s:machine_state) =
{ s with
ms_trace = [] } | let filt_state (s: machine_state) = | false | null | false | { s with ms_trace = [] } | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val filt_state : s: Vale.X64.Machine_Semantics_s.machine_state -> Vale.X64.Machine_Semantics_s.machine_state | [] | Vale.Transformers.InstructionReorder.filt_state | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.X64.Machine_Semantics_s.machine_state -> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 17,
"end_line": 419,
"start_col": 4,
"start_line": 418
} | |
Prims.Tot | val proof_run (s: machine_state) (f: st unit) : machine_state | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let proof_run (s:machine_state) (f:st unit) : machine_state =
let (), s1 = f s in
{ s1 with ms_ok = s1.ms_ok && s.ms_ok } | val proof_run (s: machine_state) (f: st unit) : machine_state
let proof_run (s: machine_state) (f: st unit) : machine_state = | false | null | false | let (), s1 = f s in
{ s1 with ms_ok = s1.ms_ok && s.ms_ok } | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Prims.op_AmpAmp",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val proof_run (s: machine_state) (f: st unit) : machine_state | [] | Vale.Transformers.InstructionReorder.proof_run | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.X64.Machine_Semantics_s.machine_state -> f: Vale.X64.Machine_Semantics_s.st Prims.unit
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 41,
"end_line": 195,
"start_col": 61,
"start_line": 193
} |
Prims.Tot | val run2 (f1 f2: st unit) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let run2 (f1 f2:st unit) (s:machine_state) : machine_state =
let open Vale.X64.Machine_Semantics_s in
run (f1;* f2;* return ()) s | val run2 (f1 f2: st unit) (s: machine_state) : machine_state
let run2 (f1 f2: st unit) (s: machine_state) : machine_state = | false | null | false | let open Vale.X64.Machine_Semantics_s in
run (let* _ = f1 in
let* _ = f2 in
return ())
s | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.run",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Vale.X64.Machine_Semantics_s.return"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val run2 (f1 f2: st unit) (s: machine_state) : machine_state | [] | Vale.Transformers.InstructionReorder.run2 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 29,
"end_line": 558,
"start_col": 2,
"start_line": 557
} |
Prims.Tot | val aux_write_exchange_allowed (w2: locations) (c1 c2: locations_with_values) (x: location) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let aux_write_exchange_allowed (w2:locations) (c1 c2:locations_with_values) (x:location) : pbool =
let cv1, cv2 =
locations_of_locations_with_values c1,
locations_of_locations_with_values c2 in
(disjoint_location_from_locations x w2) ||.
((x `L.mem` cv1 && x `L.mem` cv2) /- "non constant write") | val aux_write_exchange_allowed (w2: locations) (c1 c2: locations_with_values) (x: location) : pbool
let aux_write_exchange_allowed (w2: locations) (c1 c2: locations_with_values) (x: location) : pbool = | false | null | false | let cv1, cv2 = locations_of_locations_with_values c1, locations_of_locations_with_values c2 in
(disjoint_location_from_locations x w2) ||.
((x `L.mem` cv1 && x `L.mem` cv2) /- "non constant write") | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.Locations.location",
"Prims.list",
"Vale.Def.PossiblyMonad.op_Bar_Bar_Dot",
"Vale.Transformers.Locations.disjoint_location_from_locations",
"Vale.Def.PossiblyMonad.op_Slash_Su... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val aux_write_exchange_allowed (w2: locations) (c1 c2: locations_with_values) (x: location) : pbool | [] | Vale.Transformers.InstructionReorder.aux_write_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w2: Vale.Transformers.Locations.locations ->
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
x: Vale.Transformers.Locations.location
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 60,
"end_line": 79,
"start_col": 98,
"start_line": 74
} |
Prims.Tot | val rw_exchange_allowed (rw1 rw2: rw_set) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rw_exchange_allowed (rw1 rw2 : rw_set) : pbool =
let r1, w1, c1 = rw1.loc_reads, rw1.loc_writes, rw1.loc_constant_writes in
let r2, w2, c2 = rw2.loc_reads, rw2.loc_writes, rw2.loc_constant_writes in
(disjoint_locations r1 w2 /+< "read set of 1st not disjoint from write set of 2nd because ") &&.
(disjoint_lo... | val rw_exchange_allowed (rw1 rw2: rw_set) : pbool
let rw_exchange_allowed (rw1 rw2: rw_set) : pbool = | false | null | false | let r1, w1, c1 = rw1.loc_reads, rw1.loc_writes, rw1.loc_constant_writes in
let r2, w2, c2 = rw2.loc_reads, rw2.loc_writes, rw2.loc_constant_writes in
(disjoint_locations r1 w2 /+< "read set of 1st not disjoint from write set of 2nd because ") &&.
(disjoint_locations r2 w1 /+< "read set of 2nd not disjoint from write se... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Def.PossiblyMonad.op_Amp_Amp_Dot",
"Vale.Def.PossiblyMonad.op_Slash_Plus_Less",
"Vale.Transformers.Locations.disjoint_locations",
"Val... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val rw_exchange_allowed (rw1 rw2: rw_set) : pbool | [] | Vale.Transformers.InstructionReorder.rw_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rw1: Vale.Transformers.BoundedInstructionEffects.rw_set ->
rw2: Vale.Transformers.BoundedInstructionEffects.rw_set
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 77,
"end_line": 94,
"start_col": 52,
"start_line": 89
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let equiv_states_or_both_not_ok (s1 s2:machine_state) =
(equiv_states s1 s2) \/
((not s1.ms_ok) /\ (not s2.ms_ok)) | let equiv_states_or_both_not_ok (s1 s2: machine_state) = | false | null | false | (equiv_states s1 s2) \/ ((not s1.ms_ok) /\ (not s2.ms_ok)) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_or",
"Vale.Transformers.InstructionReorder.equiv_states",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Negation",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.logical"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val equiv_states_or_both_not_ok : s1: Vale.X64.Machine_Semantics_s.machine_state -> s2: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.logical | [] | Vale.Transformers.InstructionReorder.equiv_states_or_both_not_ok | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.X64.Machine_Semantics_s.machine_state -> s2: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.logical | {
"end_col": 36,
"end_line": 163,
"start_col": 2,
"start_line": 162
} | |
Prims.Tot | val ins_exchange_allowed (i1 i2: ins) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let ins_exchange_allowed (i1 i2 : ins) : pbool =
(
match i1, i2 with
| Instr _ _ _, Instr _ _ _ ->
(rw_exchange_allowed (rw_set_of_ins i1) (rw_set_of_ins i2))
| _, _ ->
ffalse "non-generic instructions: conservatively disallowed exchange"
) /+> normal (" for instructions " ^ print_ins i1 gcc... | val ins_exchange_allowed (i1 i2: ins) : pbool
let ins_exchange_allowed (i1 i2: ins) : pbool = | false | null | false | (match i1, i2 with
| Instr _ _ _, Instr _ _ _ -> (rw_exchange_allowed (rw_set_of_ins i1) (rw_set_of_ins i2))
| _, _ -> ffalse "non-generic instructions: conservatively disallowed exchange") /+>
normal (" for instructions " ^ print_ins i1 gcc ^ " and " ^ print_ins i2 gcc) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.Def.PossiblyMonad.op_Slash_Plus_Greater",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val ins_exchange_allowed (i1 i2: ins) : pbool | [] | Vale.Transformers.InstructionReorder.ins_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i1: Vale.X64.Machine_Semantics_s.ins -> i2: Vale.X64.Machine_Semantics_s.ins
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 85,
"end_line": 103,
"start_col": 2,
"start_line": 97
} |
Prims.GTot | val commutes (s: machine_state) (f1 f2: st unit) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let commutes (s:machine_state) (f1 f2:st unit) : GTot Type0 =
equiv_states_or_both_not_ok
(run2 f1 f2 s)
(run2 f2 f1 s) | val commutes (s: machine_state) (f1 f2: st unit) : GTot Type0
let commutes (s: machine_state) (f1 f2: st unit) : GTot Type0 = | false | null | false | equiv_states_or_both_not_ok (run2 f1 f2 s) (run2 f2 f1 s) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"sometrivial"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.Transformers.InstructionReorder.equiv_states_or_both_not_ok",
"Vale.Transformers.InstructionReorder.run2"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val commutes (s: machine_state) (f1 f2: st unit) : GTot Type0 | [] | Vale.Transformers.InstructionReorder.commutes | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: Vale.X64.Machine_Semantics_s.machine_state ->
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit
-> Prims.GTot Type0 | {
"end_col": 18,
"end_line": 563,
"start_col": 2,
"start_line": 561
} |
Prims.GTot | val equiv_ostates (s1 s2: option machine_state) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let equiv_ostates (s1 s2 : option machine_state) : GTot Type0 =
(Some? s1 = Some? s2) /\
(Some? s1 ==>
(equiv_states (Some?.v s1) (Some?.v s2))) | val equiv_ostates (s1 s2: option machine_state) : GTot Type0
let equiv_ostates (s1 s2: option machine_state) : GTot Type0 = | false | null | false | (Some? s1 = Some? s2) /\ (Some? s1 ==> (equiv_states (Some?.v s1) (Some?.v s2))) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"sometrivial"
] | [
"FStar.Pervasives.Native.option",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.l_imp",
"Vale.Transformers.InstructionReorder.equiv_states",
"FStar.Pervasives.Native.__proj__Some__item__v"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val equiv_ostates (s1 s2: option machine_state) : GTot Type0 | [] | Vale.Transformers.InstructionReorder.equiv_ostates | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s1: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state ->
s2: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state
-> Prims.GTot Type0 | {
"end_col": 44,
"end_line": 170,
"start_col": 2,
"start_line": 168
} |
Prims.GTot | val equiv_states (s1 s2: machine_state) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let equiv_states (s1 s2 : machine_state) : GTot Type0 =
(s1.ms_ok == s2.ms_ok) /\
(s1.ms_regs == s2.ms_regs) /\
(cf s1.ms_flags = cf s2.ms_flags) /\
(overflow s1.ms_flags = overflow s2.ms_flags) /\
(s1.ms_heap == s2.ms_heap) /\
(s1.ms_stack == s2.ms_stack) /\
(s1.ms_stackTaint == s2.ms_stackTaint) | val equiv_states (s1 s2: machine_state) : GTot Type0
let equiv_states (s1 s2: machine_state) : GTot Type0 = | false | null | false | (s1.ms_ok == s2.ms_ok) /\ (s1.ms_regs == s2.ms_regs) /\ (cf s1.ms_flags = cf s2.ms_flags) /\
(overflow s1.ms_flags = overflow s2.ms_flags) /\ (s1.ms_heap == s2.ms_heap) /\
(s1.ms_stack == s2.ms_stack) /\ (s1.ms_stackTaint == s2.ms_stackTaint) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"sometrivial"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.regs_t",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Prims.b2t",
"Prims.op_Equality",... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val equiv_states (s1 s2: machine_state) : GTot Type0 | [] | Vale.Transformers.InstructionReorder.equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.X64.Machine_Semantics_s.machine_state -> s2: Vale.X64.Machine_Semantics_s.machine_state
-> Prims.GTot Type0 | {
"end_col": 40,
"end_line": 145,
"start_col": 2,
"start_line": 139
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let equiv_option_states (s1 s2:option machine_state) =
(erroring_option_state s1 == erroring_option_state s2) /\
(not (erroring_option_state s1) ==> equiv_states (Some?.v s1) (Some?.v s2)) | let equiv_option_states (s1 s2: option machine_state) = | false | null | false | (erroring_option_state s1 == erroring_option_state s2) /\
(not (erroring_option_state s1) ==> equiv_states (Some?.v s1) (Some?.v s2)) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.Transformers.InstructionReorder.erroring_option_state",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Negation",
"Vale.Transformers.InstructionReorder.equiv_states",
"FStar.Per... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val equiv_option_states : s1: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state ->
s2: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state
-> Prims.logical | [] | Vale.Transformers.InstructionReorder.equiv_option_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s1: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state ->
s2: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state
-> Prims.logical | {
"end_col": 77,
"end_line": 186,
"start_col": 2,
"start_line": 185
} | |
FStar.Pervasives.Lemma | val lemma_machine_eval_ins_st_exchange (i1 i2: ins) (s: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2)))
(ensures (commutes s (machine_eval_ins_st i1) (machine_eval_ins_st i2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_machine_eval_ins_st_exchange (i1 i2 : ins) (s : machine_state) :
Lemma
(requires (!!(ins_exchange_allowed i1 i2)))
(ensures (commutes s
(machine_eval_ins_st i1)
(machine_eval_ins_st i2))) =
lemma_machine_eval_ins_st_bounded_effects i1;
lemma_machine_eval_ins_st_bo... | val lemma_machine_eval_ins_st_exchange (i1 i2: ins) (s: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2)))
(ensures (commutes s (machine_eval_ins_st i1) (machine_eval_ins_st i2)))
let lemma_machine_eval_ins_st_exchange (i1 i2: ins) (s: machine_state)
: Lemma (requires (!!(ins_exchange_allo... | false | null | true | lemma_machine_eval_ins_st_bounded_effects i1;
lemma_machine_eval_ins_st_bounded_effects i2;
let rw1 = rw_set_of_ins i1 in
let rw2 = rw_set_of_ins i2 in
lemma_commute (machine_eval_ins_st i1) (machine_eval_ins_st i2) rw1 rw2 s | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_commute",
"Vale.X64.Machine_Semantics_s.machine_eval_ins_st",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.Transformers.BoundedInstructionEffects.rw_set_of_ins",
"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_machine_eval_ins_st_exchange (i1 i2: ins) (s: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2)))
(ensures (commutes s (machine_eval_ins_st i1) (machine_eval_ins_st i2))) | [] | Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_st_exchange | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i1: Vale.X64.Machine_Semantics_s.ins ->
i2: Vale.X64.Machine_Semantics_s.ins ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires !!(Vale.Transformers.InstructionReorder.ins_exchange_allowed i1 i2))
(ensures
Vale.Transformers.InstructionReorder.commutes... | {
"end_col": 75,
"end_line": 1102,
"start_col": 2,
"start_line": 1098
} |
FStar.Pervasives.Lemma | val lemma_ins_exchange_allowed_symmetric (i1 i2: ins)
: Lemma (requires (!!(ins_exchange_allowed i1 i2))) (ensures (!!(ins_exchange_allowed i2 i1))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_ins_exchange_allowed_symmetric (i1 i2 : ins) :
Lemma
(requires (
!!(ins_exchange_allowed i1 i2)))
(ensures (
!!(ins_exchange_allowed i2 i1))) =
let rw1, rw2 = rw_set_of_ins i1, rw_set_of_ins i2 in
let r1, w1, c1 = rw1.loc_reads, rw1.loc_writes, rw1.loc_constant_writes in
let r2... | val lemma_ins_exchange_allowed_symmetric (i1 i2: ins)
: Lemma (requires (!!(ins_exchange_allowed i1 i2))) (ensures (!!(ins_exchange_allowed i2 i1)))
let lemma_ins_exchange_allowed_symmetric (i1 i2: ins)
: Lemma (requires (!!(ins_exchange_allowed i1 i2))) (ensures (!!(ins_exchange_allowed i2 i1))) = | false | null | true | let rw1, rw2 = rw_set_of_ins i1, rw_set_of_ins i2 in
let r1, w1, c1 = rw1.loc_reads, rw1.loc_writes, rw1.loc_constant_writes in
let r2, w2, c2 = rw2.loc_reads, rw2.loc_writes, rw2.loc_constant_writes in
lemma_write_exchange_allowed_symmetric w1 w2 c1 c2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.InstructionReorder.lemma_write_exchange_allowed_symmetric",
"Prims.unit",
"FStar.Perv... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_ins_exchange_allowed_symmetric (i1 i2: ins)
: Lemma (requires (!!(ins_exchange_allowed i1 i2))) (ensures (!!(ins_exchange_allowed i2 i1))) | [] | Vale.Transformers.InstructionReorder.lemma_ins_exchange_allowed_symmetric | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i1: Vale.X64.Machine_Semantics_s.ins -> i2: Vale.X64.Machine_Semantics_s.ins
-> FStar.Pervasives.Lemma
(requires !!(Vale.Transformers.InstructionReorder.ins_exchange_allowed i1 i2))
(ensures !!(Vale.Transformers.InstructionReorder.ins_exchange_allowed i2 i1)) | {
"end_col": 52,
"end_line": 133,
"start_col": 42,
"start_line": 129
} |
FStar.Pervasives.Lemma | val lemma_eval_ins_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (machine_eval_ins i s1) (machine_eval_ins i s2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_eval_ins_equiv_states (i : ins) (s1 s2 : machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
equiv_states
(machine_eval_ins i s1)
(machine_eval_ins i s2))) =
lemma_machine_eval_ins_st_equiv_states i s1 s2 | val lemma_eval_ins_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (machine_eval_ins i s1) (machine_eval_ins i s2)))
let lemma_eval_ins_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_sta... | false | null | true | lemma_machine_eval_ins_st_equiv_states i s1 s2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_st_equiv_states",
"Prims.unit",
"Vale.Transformers.InstructionReorder.equiv_states",
"Prims.squash",
"Vale.X64.Machine_Semantics_s.machine_eval_ins",
"Prims.Ni... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_eval_ins_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (machine_eval_ins i s1) (machine_eval_ins i s2))) | [] | Vale.Transformers.InstructionReorder.lemma_eval_ins_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Machine_Semantics_s.ins ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Vale.Transformers.InstructionReorder.equiv_states s1 s2)
(ensures
Vale.Transformers.InstructionReorder.equiv_states (Va... | {
"end_col": 48,
"end_line": 414,
"start_col": 2,
"start_line": 414
} |
FStar.Pervasives.Lemma | val lemma_unchanged_except_transitive (a12 a23: list location) (s1 s2 s3: machine_state)
: Lemma (requires (unchanged_except a12 s1 s2 /\ unchanged_except a23 s2 s3))
(ensures (unchanged_except (a12 `L.append` a23) s1 s3)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_unchanged_except_transitive (a12 a23:list location) (s1 s2 s3:machine_state) :
Lemma
(requires (unchanged_except a12 s1 s2 /\ unchanged_except a23 s2 s3))
(ensures (unchanged_except (a12 `L.append` a23) s1 s3)) =
let aux a : Lemma
(requires (!!(disjoint_location_from_locations a (a12 `L.append... | val lemma_unchanged_except_transitive (a12 a23: list location) (s1 s2 s3: machine_state)
: Lemma (requires (unchanged_except a12 s1 s2 /\ unchanged_except a23 s2 s3))
(ensures (unchanged_except (a12 `L.append` a23) s1 s3))
let lemma_unchanged_except_transitive (a12 a23: list location) (s1 s2 s3: machine_state... | false | null | true | let aux a
: Lemma (requires (!!(disjoint_location_from_locations a (a12 `L.append` a23))))
(ensures (eval_location a s1 == eval_location a s3)) =
lemma_disjoint_location_from_locations_append a a12 a23
in
FStar.Classical.forall_intro (FStar.Classical.move_requires aux) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Transformers.Locations.disjoint_location_from_locations",
"FStar.List.Tot.Base.append",
"Prim... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_unchanged_except_transitive (a12 a23: list location) (s1 s2 s3: machine_state)
: Lemma (requires (unchanged_except a12 s1 s2 /\ unchanged_except a23 s2 s3))
(ensures (unchanged_except (a12 `L.append` a23) s1 s3)) | [] | Vale.Transformers.InstructionReorder.lemma_unchanged_except_transitive | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a12: Prims.list Vale.Transformers.Locations.location ->
a23: Prims.list Vale.Transformers.Locations.location ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state ->
s3: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requi... | {
"end_col": 66,
"end_line": 594,
"start_col": 61,
"start_line": 589
} |
Prims.Tot | val wrap_sos (f: (machine_state -> option machine_state)) : st unit | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let wrap_sos (f:machine_state -> option machine_state) : st unit =
fun s -> (
match f s with
| None -> (), { s with ms_ok = false }
| Some s' -> (), s'
) | val wrap_sos (f: (machine_state -> option machine_state)) : st unit
let wrap_sos (f: (machine_state -> option machine_state)) : st unit = | false | null | false | fun s ->
(match f s with
| None -> (), { s with ms_ok = false }
| Some s' -> (), s') | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val wrap_sos (f: (machine_state -> option machine_state)) : st unit | [] | Vale.Transformers.InstructionReorder.wrap_sos | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
(_: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state)
-> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 5,
"end_line": 1037,
"start_col": 2,
"start_line": 1033
} |
Prims.Tot | val locations_of_locations_with_values (lv: locations_with_values) : locations | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec locations_of_locations_with_values (lv:locations_with_values) : locations =
match lv with
| [] -> []
| (|l,v|) :: lv ->
l :: locations_of_locations_with_values lv | val locations_of_locations_with_values (lv: locations_with_values) : locations
let rec locations_of_locations_with_values (lv: locations_with_values) : locations = | false | null | false | match lv with
| [] -> []
| (| l , v |) :: lv -> l :: locations_of_locations_with_values lv | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Prims.Nil",
"Vale.Transformers.Locations.location",
"Vale.Transformers.Locations.location_eq",
"Vale.Transformers.Locations.location_val_eqt",
"Prims.list",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Prims.C... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val locations_of_locations_with_values (lv: locations_with_values) : locations | [
"recursion"
] | Vale.Transformers.InstructionReorder.locations_of_locations_with_values | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lv: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> Vale.Transformers.Locations.locations | {
"end_col": 46,
"end_line": 59,
"start_col": 2,
"start_line": 56
} |
FStar.Pervasives.Lemma | val lemma_equiv_code_codes (c: code) (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_codes (c :: ... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_equiv_code_codes (c:code) (cs:codes) (fuel:nat) (s:machine_state) :
Lemma
(ensures (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_codes (c :: cs)... | val lemma_equiv_code_codes (c: code) (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_codes (c :: ... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
let s_1 = run f1 s in
let s_1_2 = run f2 s_1 in
let s_12 =
run (let* _ = f1 in
f2)
s
in
let s12 = run f12 s in
... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.bool",
"Vale.Transformers.InstructionReorder.lemma_not_ok_propagate_codes",
"Prims.unit",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_equiv_code_codes (c: code) (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_codes (c :: ... | [] | Vale.Transformers.InstructionReorder.lemma_equiv_code_codes | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(ensures
(let f1 =
Vale.Transformers.InstructionReorder.wrap_sos (Vale.X64.Machine_Semantics_s.machine_eval_... | {
"end_col": 3,
"end_line": 1272,
"start_col": 2,
"start_line": 1255
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_code_codes_aux3 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_bounded_effects_code_codes_aux3 (c:code) (cs:codes) (rw:rw_set) (fuel:nat) s1 s2 :
Lemma
(requires (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw (f1 ;* f2)) ... | val lemma_bounded_effects_code_codes_aux3 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f =
(let* _ = f1 in
f2)
in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
let pre = bounded_effects rw f in
lemma_equiv_code_codes c cs fuel s1;
lemma_equiv_cod... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_unchanged_at_reads_implies_both_ok_equal",
"Prims.unit",
"Prims._asser... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_code_codes_aux3 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | [] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux3 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
fuel: Prims.nat ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requ... | {
"end_col": 59,
"end_line": 1355,
"start_col": 2,
"start_line": 1345
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_code_codes_aux1 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s a: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_s... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_bounded_effects_code_codes_aux1 (c:code) (cs:codes) (rw:rw_set) (fuel:nat) s a :
Lemma
(requires (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_sos (machine_eval_c... | val lemma_bounded_effects_code_codes_aux1 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s a: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_s... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f =
(let* _ = f1 in
f2)
in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
let s_12 =
run (let* _ = f1 in
f2)
s
in
let s12 = run f12 s in
lemma_equiv... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.Locations.location",
"Vale.Transformers.InstructionReorder.lemma_only_affects_to_unchanged_except... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_code_codes_aux1 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s a: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f12 = wrap_s... | [] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux1 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
a: Vale.Transformers.Locations.location
-> FStar.Pervasives.Lemma
(requires
... | {
"end_col": 58,
"end_line": 1296,
"start_col": 2,
"start_line": 1287
} |
FStar.Pervasives.Lemma | val lemma_write_same_constants_append (c1 c1' c2: locations_with_values)
: Lemma
(ensures
(!!(write_same_constants (c1 `L.append` c1') c2) =
(!!(write_same_constants c1 c2) && !!(write_same_constants c1' c2)))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_write_same_constants_append (c1 c1' c2:locations_with_values) :
Lemma
(ensures (
!!(write_same_constants (c1 `L.append` c1') c2) = (
!!(write_same_constants c1 c2) &&
!!(write_same_constants c1' c2)))) =
match c1 with
| [] -> ()
| x :: xs -> lemma_write_same_constan... | val lemma_write_same_constants_append (c1 c1' c2: locations_with_values)
: Lemma
(ensures
(!!(write_same_constants (c1 `L.append` c1') c2) =
(!!(write_same_constants c1 c2) && !!(write_same_constants c1' c2))))
let rec lemma_write_same_constants_append (c1 c1' c2: locations_with_values)
: Lemm... | false | null | true | match c1 with
| [] -> ()
| x :: xs -> lemma_write_same_constants_append xs c1' c2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_write_same_constants_append",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.b2t",
"Prims.op_Equalit... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_write_same_constants_append (c1 c1' c2: locations_with_values)
: Lemma
(ensures
(!!(write_same_constants (c1 `L.append` c1') c2) =
(!!(write_same_constants c1 c2) && !!(write_same_constants c1' c2)))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_write_same_constants_append | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c1': Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> FStar.Pervasives.Lemma
(ensures
!!(Vale.Transformers.InstructionReorder.wri... | {
"end_col": 58,
"end_line": 666,
"start_col": 2,
"start_line": 664
} |
FStar.Pervasives.Lemma | val lemma_unchanged_at_and_except (as0: list location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (unchanged_except as0 s1 s2)))
(ensures ((unchanged_except [] s1 s2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_unchanged_at_and_except (as0:list location) (s1 s2:machine_state) :
Lemma
(requires (
(unchanged_at as0 s1 s2) /\
(unchanged_except as0 s1 s2)))
(ensures (
(unchanged_except [] s1 s2))) =
match as0 with
| [] -> ()
| x :: xs ->
lemma_unchanged_at_and_except xs s1... | val lemma_unchanged_at_and_except (as0: list location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (unchanged_except as0 s1 s2)))
(ensures ((unchanged_except [] s1 s2)))
let rec lemma_unchanged_at_and_except (as0: list location) (s1 s2: machine_state)
: Lemma (requires ((unchange... | false | null | true | match as0 with
| [] -> ()
| x :: xs -> lemma_unchanged_at_and_except xs s1 s2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_unchanged_at_and_except",
"Prims.unit",
"Prims.l_and",
"Vale.Transformers.BoundedInstructionEffects.unchanged_at",
"Vale.Transformers.BoundedInstructionEffect... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_unchanged_at_and_except (as0: list location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (unchanged_except as0 s1 s2)))
(ensures ((unchanged_except [] s1 s2))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_unchanged_at_and_except | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
as0: Prims.list Vale.Transformers.Locations.location ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
Vale.Transformers.BoundedInstructionEffects.unchanged_at as0 s1 s2 /\
Vale.Transformers.Bounde... | {
"end_col": 42,
"end_line": 803,
"start_col": 2,
"start_line": 800
} |
FStar.Pervasives.Lemma | val lemma_disjoint_location_from_locations_append (a: location) (as1 as2: list location)
: Lemma
((!!(disjoint_location_from_locations a as1) /\ !!(disjoint_location_from_locations a as2)) <==>
(!!(disjoint_location_from_locations a (as1 `L.append` as2)))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_disjoint_location_from_locations_append
(a:location) (as1 as2:list location) :
Lemma (
(!!(disjoint_location_from_locations a as1) /\
!!(disjoint_location_from_locations a as2)) <==>
(!!(disjoint_location_from_locations a (as1 `L.append` as2)))) =
match as1 with
| [] -> ()
| x :: xs... | val lemma_disjoint_location_from_locations_append (a: location) (as1 as2: list location)
: Lemma
((!!(disjoint_location_from_locations a as1) /\ !!(disjoint_location_from_locations a as2)) <==>
(!!(disjoint_location_from_locations a (as1 `L.append` as2))))
let rec lemma_disjoint_location_from_locations_ap... | false | null | true | match as1 with
| [] -> ()
| x :: xs -> lemma_disjoint_location_from_locations_append a xs as2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.Locations.location",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_append",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"Prims.l_and",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Transformers.Locations... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_disjoint_location_from_locations_append (a: location) (as1 as2: list location)
: Lemma
((!!(disjoint_location_from_locations a as1) /\ !!(disjoint_location_from_locations a as2)) <==>
(!!(disjoint_location_from_locations a (as1 `L.append` as2)))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_append | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Vale.Transformers.Locations.location ->
as1: Prims.list Vale.Transformers.Locations.location ->
as2: Prims.list Vale.Transformers.Locations.location
-> FStar.Pervasives.Lemma
(ensures
!!(Vale.Transformers.Locations.disjoint_location_from_locations a as1) /\
!!(Vale.Transformers.Locatio... | {
"end_col": 58,
"end_line": 584,
"start_col": 2,
"start_line": 581
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_code_codes_aux4 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_bounded_effects_code_codes_aux4 (c:code) (cs:codes) (rw:rw_set) (fuel:nat) s1 s2 :
Lemma
(requires (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw (f1 ;* f2)) ... | val lemma_bounded_effects_code_codes_aux4 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f =
(let* _ = f1 in
f2)
in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
let pre = bounded_effects rw f in
lemma_equiv_code_codes c cs fuel s1;
lemma_equiv_cod... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims._assert",
"Prims.eq2",
"Vale.X64.Machine_Semantics_s.run",
"Prims.unit",
"Vale.Transformers.BoundedInst... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_code_codes_aux4 (c: code) (cs: codes) (rw: rw_set) (fuel: nat) (s1 s2: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effec... | [] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux4 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
fuel: Prims.nat ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requ... | {
"end_col": 33,
"end_line": 1381,
"start_col": 2,
"start_line": 1368
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_code_codes (c: code) (cs: codes) (rw: rw_set) (fuel: nat)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw
... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_bounded_effects_code_codes (c:code) (cs:codes) (rw:rw_set) (fuel:nat) :
Lemma
(requires (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw (f1 ;* f2))))
(ensu... | val lemma_bounded_effects_code_codes (c: code) (cs: codes) (rw: rw_set) (fuel: nat)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw
... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f =
let* _ = f1 in
f2
in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
let pre = bounded_effects rw f in
let aux s = FStar.Classical.move_requires (lemma_bounded... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Prims.nat",
"FStar.Classical.forall_intro_2",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_imp",
"Prims.l_and",
"Vale.Transformers.BoundedInstructionEffects.bou... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_code_codes (c: code) (cs: codes) (rw: rw_set) (fuel: nat)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(bounded_effects rw
... | [] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
fuel: Prims.nat
-> FStar.Pervasives.Lemma
(requires
(let f1 =
Vale.Transformers.InstructionReorder.wrap_sos (Vale.X64.Machine_Semantics... | {
"end_col": 36,
"end_line": 1406,
"start_col": 2,
"start_line": 1393
} |
FStar.Pervasives.Lemma | val lemma_feq_bounded_effects (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (bounded_effects rw f1 /\ FStar.FunctionalExtensionality.feq f1 f2))
(ensures (bounded_effects rw f2)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_feq_bounded_effects (rw:rw_set) (f1 f2:st unit) :
Lemma
(requires (bounded_effects rw f1 /\ FStar.FunctionalExtensionality.feq f1 f2))
(ensures (bounded_effects rw f2)) =
let open FStar.FunctionalExtensionality in
assert (only_affects rw.loc_writes f2);
let rec aux w s :
Lemma
(requi... | val lemma_feq_bounded_effects (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (bounded_effects rw f1 /\ FStar.FunctionalExtensionality.feq f1 f2))
(ensures (bounded_effects rw f2))
let lemma_feq_bounded_effects (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (bounded_effects rw f1 /\ FStar.FunctionalExten... | false | null | true | let open FStar.FunctionalExtensionality in
assert (only_affects rw.loc_writes f2);
let rec aux w s
: Lemma (requires (feq f1 f2 /\ constant_on_execution w f1 s))
(ensures (constant_on_execution w f2 s))
[SMTPat (constant_on_execution w f2 s)] =
match w with
| [] -> ()
| x :: xs -> aux xs s
in
asse... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Prims._assert",
"Prims.l_Forall",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_feq_bounded_effects (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (bounded_effects rw f1 /\ FStar.FunctionalExtensionality.feq f1 f2))
(ensures (bounded_effects rw f2)) | [] | Vale.Transformers.InstructionReorder.lemma_feq_bounded_effects | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit
-> FStar.Pervasives.Lemma
(requires
Vale.Transformers.BoundedInstructionEffects.bounded_effects rw f1 /\
FStar.FunctionalExtensi... | {
"end_col": 3,
"end_line": 1066,
"start_col": 2,
"start_line": 1043
} |
FStar.Pervasives.Lemma | val lemma_write_same_constants_symmetric (c1 c2: locations_with_values)
: Lemma (ensures (!!(write_same_constants c1 c2) = !!(write_same_constants c2 c1))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_write_same_constants_symmetric (c1 c2:locations_with_values) :
Lemma
(ensures (!!(write_same_constants c1 c2) = !!(write_same_constants c2 c1))) =
match c1, c2 with
| [], [] -> ()
| x :: xs, [] ->
lemma_write_same_constants_symmetric xs []
| [], y :: ys ->
lemma_write_same_constants_... | val lemma_write_same_constants_symmetric (c1 c2: locations_with_values)
: Lemma (ensures (!!(write_same_constants c1 c2) = !!(write_same_constants c2 c1)))
let rec lemma_write_same_constants_symmetric (c1 c2: locations_with_values)
: Lemma (ensures (!!(write_same_constants c1 c2) = !!(write_same_constants c2 c1... | false | null | true | match c1, c2 with
| [], [] -> ()
| x :: xs, [] -> lemma_write_same_constants_symmetric xs []
| [], y :: ys -> lemma_write_same_constants_symmetric [] ys
| x :: xs, y :: ys ->
lemma_write_same_constants_symmetric c1 ys;
lemma_write_same_constants_symmetric xs c2;
lemma_write_same_constants_symmetric xs ys | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Vale.Transformers.InstructionReorder.lemma_write_same_constants_symmetric",
"Prims.Nil",
"Prims.unit",
"Prims.l_Tru... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_write_same_constants_symmetric (c1 c2: locations_with_values)
: Lemma (ensures (!!(write_same_constants c1 c2) = !!(write_same_constants c2 c1))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_write_same_constants_symmetric | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> FStar.Pervasives.Lemma
(ensures
!!(Vale.Transformers.InstructionReorder.write_same_constants c1 c2) =
!!(Vale.Transformers.InstructionReorder.write... | {
"end_col": 46,
"end_line": 117,
"start_col": 2,
"start_line": 108
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_on_functional_extensionality (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1))
(ensures (bounded_effects rw f2)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_bounded_effects_on_functional_extensionality (rw:rw_set) (f1 f2:st unit) :
Lemma
(requires (FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1))
(ensures (bounded_effects rw f2)) =
let pre = FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1 in
assert (only_affects ... | val lemma_bounded_effects_on_functional_extensionality (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1))
(ensures (bounded_effects rw f2))
let lemma_bounded_effects_on_functional_extensionality (rw: rw_set) (f1 f2: st unit)
: Lemma (requir... | false | null | true | let pre = FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1 in
assert (only_affects rw.loc_writes f1 <==> only_affects rw.loc_writes f2);
let rec aux c s
: Lemma (requires (pre /\ constant_on_execution c f1 s))
(ensures (constant_on_execution c f2 s)) =
match c with
| [] -> ()
| (| l , v... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__pro... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_on_functional_extensionality (rw: rw_set) (f1 f2: st unit)
: Lemma (requires (FStar.FunctionalExtensionality.feq f1 f2 /\ bounded_effects rw f1))
(ensures (bounded_effects rw f2)) | [] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_on_functional_extensionality | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rw: Vale.Transformers.BoundedInstructionEffects.rw_set ->
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit
-> FStar.Pervasives.Lemma
(requires
FStar.FunctionalExtensionality.feq f1 f2 /\
Vale.Transformers.BoundedInstructionEffects.boun... | {
"end_col": 36,
"end_line": 1238,
"start_col": 39,
"start_line": 1218
} |
FStar.Pervasives.Lemma | val lemma_both_not_ok (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures ((run2 f1 f2 s).ms_ok = (run2 f2 f1 s).ms_ok)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_both_not_ok (f1 f2:st unit) (rw1 rw2:rw_set) (s:machine_state) :
Lemma
(requires (
(bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\
!!(rw_exchange_allowed rw1 rw2)))
(ensures (
(run2 f1 f2 s).ms_ok =
(run2 f2 f1 s).ms_ok)) =
if (run f1 s).ms_ok then (... | val lemma_both_not_ok (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures ((run2 f1 f2 s).ms_ok = (run2 f2 f1 s).ms_ok))
let lemma_both_not_ok (f1 f2: st unit) (rw1 rw2: rw_set... | false | null | true | if (run f1 s).ms_ok
then (lemma_disjoint_implies_unchanged_at rw2.loc_reads rw1.loc_writes s (run f1 s));
if (run f2 s).ms_ok
then (lemma_disjoint_implies_unchanged_at rw1.loc_reads rw2.loc_writes s (run f2 s)) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.run",
"Vale.Transformers.InstructionReorder.lemma_disjoi... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_both_not_ok (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures ((run2 f1 f2 s).ms_ok = (run2 f2 f1 s).ms_ok)) | [] | Vale.Transformers.InstructionReorder.lemma_both_not_ok | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit ->
rw1: Vale.Transformers.BoundedInstructionEffects.rw_set ->
rw2: Vale.Transformers.BoundedInstructionEffects.rw_set ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(... | {
"end_col": 11,
"end_line": 864,
"start_col": 2,
"start_line": 859
} |
FStar.Pervasives.Lemma | val lemma_instr_write_outputs_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_instr_write_outputs_equiv_states
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args)
(s_orig1 s1:machine_state)
(s_orig2 s2:machine_state) :
Lemma
(requires (
(equiv_states s_orig1 s_orig2) /\
(equiv_states s1 s2)))
... | val lemma_instr_write_outputs_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
... | false | null | true | match outs with
| [] -> ()
| (_, i) :: outs ->
(let (v: instr_val_t i), (vs: instr_ret_t outs) =
match outs with
| [] -> (vs, ())
| _ :: _ ->
let vs = coerce vs in
(fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs = coerce oprs in
lemma_instr_write_output... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.instr_ret_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.instr_val_t",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_instr_write_outputs_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_instr_write_outputs_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
outs: Prims.list Vale.X64.Instruction_s.instr_out ->
args: Prims.list Vale.X64.Instruction_s.instr_operand ->
vs: Vale.X64.Instruction_s.instr_ret_t outs ->
oprs: Vale.X64.Instruction_s.instr_operands_t outs args ->
s_orig1: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Sem... | {
"end_col": 5,
"end_line": 323,
"start_col": 2,
"start_line": 302
} |
FStar.Pervasives.Lemma | val lemma_bounded_effects_code_codes_aux2 (c: code) (cs: codes) (fuel: nat) (cw s: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(constant_on_execution cw
... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_bounded_effects_code_codes_aux2 (c:code) (cs:codes) (fuel:nat) cw s :
Lemma
(requires (
let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(constant_on_execution cw (f1;*f2) s)))
... | val lemma_bounded_effects_code_codes_aux2 (c: code) (cs: codes) (fuel: nat) (cw s: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(constant_on_execution cw
... | false | null | true | let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
let f =
(let* _ = f1 in
f2)
in
let f12 = wrap_sos (machine_eval_codes (c :: cs) fuel) in
lemma_equiv_code_codes c cs fuel s;
if (run f s).ms_ok
then
(match cw with
| [] ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Prims.nat",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.ru... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_bounded_effects_code_codes_aux2 (c: code) (cs: codes) (fuel: nat) (cw s: _)
: Lemma
(requires
(let open Vale.X64.Machine_Semantics_s in
let f1 = wrap_sos (machine_eval_code c fuel) in
let f2 = wrap_sos (machine_eval_codes cs fuel) in
(constant_on_execution cw
... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux2 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.X64.Machine_Semantics_s.code ->
cs: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
cw: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
(let f1 =
Vale.... | {
"end_col": 11,
"end_line": 1320,
"start_col": 2,
"start_line": 1308
} |
FStar.Pervasives.Lemma | val lemma_value_of_const_loc_mem (c: locations_with_values) (l: location_eq) (v: location_val_eqt l)
: Lemma
(requires (L.mem l (locations_of_locations_with_values c) /\ value_of_const_loc c l = v))
(ensures (L.mem (| l, v |) c)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_value_of_const_loc_mem (c:locations_with_values) (l:location_eq) (v:location_val_eqt l) :
Lemma
(requires (
L.mem l (locations_of_locations_with_values c) /\
value_of_const_loc c l = v))
(ensures (L.mem (|l,v|) c)) =
let x :: xs = c in
if dfst x = l then () else lemma_value_o... | val lemma_value_of_const_loc_mem (c: locations_with_values) (l: location_eq) (v: location_val_eqt l)
: Lemma
(requires (L.mem l (locations_of_locations_with_values c) /\ value_of_const_loc c l = v))
(ensures (L.mem (| l, v |) c))
let rec lemma_value_of_const_loc_mem
(c: locations_with_values)
... | false | null | true | let x :: xs = c in
if dfst x = l then () else lemma_value_of_const_loc_mem xs l v | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.Locations.location_eq",
"Vale.Transformers.Locations.location_val_eqt",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Prims.list",
"Prims.op_Equality",
"FStar.Pervasives.dfst",
"Prims.bool",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_value_of_const_loc_mem (c: locations_with_values) (l: location_eq) (v: location_val_eqt l)
: Lemma
(requires (L.mem l (locations_of_locations_with_values c) /\ value_of_const_loc c l = v))
(ensures (L.mem (| l, v |) c)) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_value_of_const_loc_mem | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
l: Vale.Transformers.Locations.location_eq ->
v: Vale.Transformers.Locations.location_val_eqt l
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.mem l
(Vale.Transformers.InstructionReorder.locations_of_... | {
"end_col": 64,
"end_line": 694,
"start_col": 33,
"start_line": 692
} |
FStar.Pervasives.Lemma | val lemma_write_same_constants_mem_both (c1 c2: locations_with_values) (l: location_eq)
: Lemma
(requires
(!!(write_same_constants c1 c2) /\ L.mem l (locations_of_locations_with_values c1) /\
L.mem l (locations_of_locations_with_values c2)))
(ensures (value_of_const_loc c1 l = value_of... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_write_same_constants_mem_both (c1 c2:locations_with_values)
(l:location_eq) :
Lemma
(requires (!!(write_same_constants c1 c2) /\
L.mem l (locations_of_locations_with_values c1) /\
L.mem l (locations_of_locations_with_values c2)))
(ensures (value_of_const_loc c1 ... | val lemma_write_same_constants_mem_both (c1 c2: locations_with_values) (l: location_eq)
: Lemma
(requires
(!!(write_same_constants c1 c2) /\ L.mem l (locations_of_locations_with_values c1) /\
L.mem l (locations_of_locations_with_values c2)))
(ensures (value_of_const_loc c1 l = value_of... | false | null | true | let x :: xs = c1 in
let y :: ys = c2 in
if dfst x = l
then
(if dfst y = l
then ()
else
(lemma_write_same_constants_symmetric c1 c2;
lemma_write_same_constants_symmetric ys c1;
lemma_write_same_constants_mem_both c1 ys l))
else (lemma_write_same_constants_mem_both xs c2 l) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.Locations.location_eq",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Prims.list",
"Prims.op_Equality",
"FStar.Pervasives.dfst",
"Vale.Transformers.Locations.location_val_eqt",
"Prims.bool",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_write_same_constants_mem_both (c1 c2: locations_with_values) (l: location_eq)
: Lemma
(requires
(!!(write_same_constants c1 c2) /\ L.mem l (locations_of_locations_with_values c1) /\
L.mem l (locations_of_locations_with_values c2)))
(ensures (value_of_const_loc c1 l = value_of... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_write_same_constants_mem_both | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
l: Vale.Transformers.Locations.location_eq
-> FStar.Pervasives.Lemma
(requires
!!(Vale.Transformers.InstructionReorder.write_same_constants c1 c2... | {
"end_col": 3,
"end_line": 685,
"start_col": 67,
"start_line": 674
} |
FStar.Pervasives.Lemma | val lemma_append_single (xs: list 'a) (y: 'a) (i: nat)
: Lemma (requires (i == L.length xs))
(ensures
(L.length (xs `L.append` [y]) = L.length xs + 1 /\ L.index (xs `L.append` [y]) i == y)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_append_single (xs:list 'a) (y:'a) (i:nat) :
Lemma
(requires (i == L.length xs))
(ensures (
L.length (xs `L.append` [y]) = L.length xs + 1 /\
L.index (xs `L.append` [y]) i == y)) =
match xs with
| [] -> ()
| x :: xs -> lemma_append_single xs y (i - 1) | val lemma_append_single (xs: list 'a) (y: 'a) (i: nat)
: Lemma (requires (i == L.length xs))
(ensures
(L.length (xs `L.append` [y]) = L.length xs + 1 /\ L.index (xs `L.append` [y]) i == y))
let rec lemma_append_single (xs: list 'a) (y: 'a) (i: nat)
: Lemma (requires (i == L.length xs))
(ensu... | false | null | true | match xs with
| [] -> ()
| x :: xs -> lemma_append_single xs y (i - 1) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Prims.nat",
"Vale.Transformers.InstructionReorder.lemma_append_single",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.eq2",
"FStar.List.Tot.Base.length",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.append",
"Prims.Cons",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_append_single (xs: list 'a) (y: 'a) (i: nat)
: Lemma (requires (i == L.length xs))
(ensures
(L.length (xs `L.append` [y]) = L.length xs + 1 /\ L.index (xs `L.append` [y]) i == y)) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_append_single | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | xs: Prims.list 'a -> y: 'a -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires i == FStar.List.Tot.Base.length xs)
(ensures
FStar.List.Tot.Base.length (xs @ [y]) = FStar.List.Tot.Base.length xs + 1 /\
FStar.List.Tot.Base.index (xs @ [y]) i == y) | {
"end_col": 47,
"end_line": 1943,
"start_col": 2,
"start_line": 1941
} |
Prims.Tot | val write_same_constants (c1 c2: locations_with_values) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let write_same_constants (c1 c2:locations_with_values) : pbool =
for_all (fun (x1:location_with_value) ->
for_all (fun (x2:location_with_value) ->
let (| l1, v1 |) = x1 in
let (| l2, v2 |) = x2 in
(if l1 = l2 then v1 = v2 else true) /- "not writing same constants"
) c2
... | val write_same_constants (c1 c2: locations_with_values) : pbool
let write_same_constants (c1 c2: locations_with_values) : pbool = | false | null | false | for_all (fun (x1: location_with_value) ->
for_all (fun (x2: location_with_value) ->
let (| l1 , v1 |) = x1 in
let (| l2 , v2 |) = x2 in
(if l1 = l2 then v1 = v2 else true) /- "not writing same constants")
c2)
c1 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Def.PossiblyMonad.for_all",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Vale.Transformers.Locations.location_eq",
"Vale.Transformers.Locations.location_val_eqt",
"Vale.Def.PossiblyMonad.op_Slash_Subtraction"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val write_same_constants (c1 c2: locations_with_values) : pbool | [] | Vale.Transformers.InstructionReorder.write_same_constants | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 8,
"end_line": 72,
"start_col": 2,
"start_line": 66
} |
FStar.Pervasives.Lemma | val lemma_write_exchange_allowed_symmetric (w1 w2: locations) (c1 c2: locations_with_values)
: Lemma
(ensures (!!(write_exchange_allowed w1 w2 c1 c2) = !!(write_exchange_allowed w2 w1 c2 c1))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_write_exchange_allowed_symmetric (w1 w2:locations) (c1 c2:locations_with_values) :
Lemma
(ensures (!!(write_exchange_allowed w1 w2 c1 c2) = !!(write_exchange_allowed w2 w1 c2 c1))) =
lemma_write_same_constants_symmetric c1 c2 | val lemma_write_exchange_allowed_symmetric (w1 w2: locations) (c1 c2: locations_with_values)
: Lemma
(ensures (!!(write_exchange_allowed w1 w2 c1 c2) = !!(write_exchange_allowed w2 w1 c2 c1)))
let lemma_write_exchange_allowed_symmetric (w1 w2: locations) (c1 c2: locations_with_values)
: Lemma
(ensures (... | false | null | true | lemma_write_same_constants_symmetric c1 c2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.InstructionReorder.lemma_write_same_constants_symmetric",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"Vale.Def.Possibl... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_write_exchange_allowed_symmetric (w1 w2: locations) (c1 c2: locations_with_values)
: Lemma
(ensures (!!(write_exchange_allowed w1 w2 c1 c2) = !!(write_exchange_allowed w2 w1 c2 c1))) | [] | Vale.Transformers.InstructionReorder.lemma_write_exchange_allowed_symmetric | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w1: Vale.Transformers.Locations.locations ->
w2: Vale.Transformers.Locations.locations ->
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values
-> FStar.Pervasives.Lemma
(ensures
!!(Vale.Transformers.In... | {
"end_col": 44,
"end_line": 122,
"start_col": 2,
"start_line": 122
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let erroring_option_state (s:option machine_state) =
match s with
| None -> true
| Some s -> not (s.ms_ok) | let erroring_option_state (s: option machine_state) = | false | null | false | match s with
| None -> true
| Some s -> not (s.ms_ok) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_Negation",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.bool"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val erroring_option_state : s: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state -> Prims.bool | [] | Vale.Transformers.InstructionReorder.erroring_option_state | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Pervasives.Native.option Vale.X64.Machine_Semantics_s.machine_state -> Prims.bool | {
"end_col": 27,
"end_line": 178,
"start_col": 2,
"start_line": 176
} | |
Prims.Tot | val wrap_ss (f: (machine_state -> machine_state)) : st unit | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let wrap_ss (f:machine_state -> machine_state) : st unit =
let open Vale.X64.Machine_Semantics_s in
let* s = get in
set (f s) | val wrap_ss (f: (machine_state -> machine_state)) : st unit
let wrap_ss (f: (machine_state -> machine_state)) : st unit = | false | null | false | let open Vale.X64.Machine_Semantics_s in
let* s = get in
set (f s) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.st"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val wrap_ss (f: (machine_state -> machine_state)) : st unit | [] | Vale.Transformers.InstructionReorder.wrap_ss | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: Vale.X64.Machine_Semantics_s.machine_state -> Vale.X64.Machine_Semantics_s.machine_state)
-> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 11,
"end_line": 1030,
"start_col": 2,
"start_line": 1028
} |
FStar.Pervasives.Lemma | val lemma_unchanged_except_append_symmetric (a1 a2: list location) (s1 s2: machine_state)
: Lemma (requires (unchanged_except (a1 `L.append` a2) s1 s2))
(ensures (unchanged_except (a2 `L.append` a1) s1 s2)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_unchanged_except_append_symmetric (a1 a2:list location) (s1 s2:machine_state) :
Lemma
(requires (unchanged_except (a1 `L.append` a2) s1 s2))
(ensures (unchanged_except (a2 `L.append` a1) s1 s2)) =
let aux a : Lemma
(requires (
(!!(disjoint_location_from_locations a (a1 `L.append` a2))) ... | val lemma_unchanged_except_append_symmetric (a1 a2: list location) (s1 s2: machine_state)
: Lemma (requires (unchanged_except (a1 `L.append` a2) s1 s2))
(ensures (unchanged_except (a2 `L.append` a1) s1 s2))
let lemma_unchanged_except_append_symmetric (a1 a2: list location) (s1 s2: machine_state)
: Lemma (... | false | null | true | let aux a
: Lemma
(requires
((!!(disjoint_location_from_locations a (a1 `L.append` a2))) \/
(!!(disjoint_location_from_locations a (a2 `L.append` a1)))))
(ensures (eval_location a s1 == eval_location a s2)) =
lemma_disjoint_location_from_locations_append a a1 a2;
lemma_disjoint_loc... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"Prims.l_or",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Transformers.Locations.disjoint_location_from_locations",
"FStar.List.Tot.Base.... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_unchanged_except_append_symmetric (a1 a2: list location) (s1 s2: machine_state)
: Lemma (requires (unchanged_except (a1 `L.append` a2) s1 s2))
(ensures (unchanged_except (a2 `L.append` a1) s1 s2)) | [] | Vale.Transformers.InstructionReorder.lemma_unchanged_except_append_symmetric | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a1: Prims.list Vale.Transformers.Locations.location ->
a2: Prims.list Vale.Transformers.Locations.location ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires Vale.Transformers.BoundedInstructionEffects.unchange... | {
"end_col": 66,
"end_line": 607,
"start_col": 59,
"start_line": 599
} |
FStar.Pervasives.Lemma | val lemma_disjoint_location_from_locations_mem (a1 a2: list location) (a: location)
: Lemma (requires ((L.mem a a1) /\ !!(disjoint_locations a1 a2)))
(ensures (!!(disjoint_location_from_locations a a2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_disjoint_location_from_locations_mem
(a1 a2:list location) (a:location) :
Lemma
(requires (
(L.mem a a1) /\
!!(disjoint_locations a1 a2)))
(ensures (
!!(disjoint_location_from_locations a a2))) =
match a1 with
| [_] -> ()
| x :: xs ->
if a = x then () else
... | val lemma_disjoint_location_from_locations_mem (a1 a2: list location) (a: location)
: Lemma (requires ((L.mem a a1) /\ !!(disjoint_locations a1 a2)))
(ensures (!!(disjoint_location_from_locations a a2)))
let rec lemma_disjoint_location_from_locations_mem (a1 a2: list location) (a: location)
: Lemma (requi... | false | null | true | match a1 with
| [_] -> ()
| x :: xs -> if a = x then () else lemma_disjoint_location_from_locations_mem xs a2 a | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Prims.op_Equality",
"Prims.bool",
"Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Transforme... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val lemma_disjoint_location_from_locations_mem (a1 a2: list location) (a: location)
: Lemma (requires ((L.mem a a1) /\ !!(disjoint_locations a1 a2)))
(ensures (!!(disjoint_location_from_locations a a2))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a1: Prims.list Vale.Transformers.Locations.location ->
a2: Prims.list Vale.Transformers.Locations.location ->
a: Vale.Transformers.Locations.location
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.mem a a1 /\ !!(Vale.Transformers.Locations.disjoint_locations a1 a2))
(ensures ... | {
"end_col": 54,
"end_line": 622,
"start_col": 2,
"start_line": 618
} |
FStar.Pervasives.Lemma | val lemma_instr_write_output_explicit_equiv_states
(i: instr_operand_explicit)
(v: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_wri... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_instr_write_output_explicit_equiv_states
(i:instr_operand_explicit) (v:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(s_orig1 s1 s_orig2 s2:machine_state) :
Lemma
(requires (
(equiv_states s_orig1 s_orig2) /\
(equiv_states s1 s2)))
(ensures (
(equiv_states
(... | val lemma_instr_write_output_explicit_equiv_states
(i: instr_operand_explicit)
(v: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_wri... | false | null | true | let snew1, snew2 =
(instr_write_output_explicit i v o s_orig1 s1), (instr_write_output_explicit i v o s_orig2 s2)
in
assert (equiv_states_ext snew1 snew2) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Instruction_s.instr_operand_explicit",
"Vale.X64.Instruction_s.instr_val_t",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.instr_operand_t",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims._assert",
"Vale.Transformers.InstructionReorder.equiv_states_ext",
"Prims.unit",
"FSta... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"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_el... | null | val lemma_instr_write_output_explicit_equiv_states
(i: instr_operand_explicit)
(v: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_wri... | [] | Vale.Transformers.InstructionReorder.lemma_instr_write_output_explicit_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Instruction_s.instr_operand_explicit ->
v: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpEx i) ->
o: Vale.X64.Instruction_s.instr_operand_t i ->
s_orig1: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s_orig2: Vale.X64... | {
"end_col": 39,
"end_line": 285,
"start_col": 62,
"start_line": 281
} |
FStar.Pervasives.Lemma | val lemma_disjoint_implies_unchanged_at (reads changes: list location) (s1 s2: machine_state)
: Lemma (requires (!!(disjoint_locations reads changes) /\ unchanged_except changes s1 s2))
(ensures (unchanged_at reads s1 s2)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_disjoint_implies_unchanged_at (reads changes:list location) (s1 s2:machine_state) :
Lemma
(requires (!!(disjoint_locations reads changes) /\
unchanged_except changes s1 s2))
(ensures (unchanged_at reads s1 s2)) =
match reads with
| [] -> ()
| x :: xs ->
lemma_disjoint_im... | val lemma_disjoint_implies_unchanged_at (reads changes: list location) (s1 s2: machine_state)
: Lemma (requires (!!(disjoint_locations reads changes) /\ unchanged_except changes s1 s2))
(ensures (unchanged_at reads s1 s2))
let rec lemma_disjoint_implies_unchanged_at (reads changes: list location) (s1 s2: mach... | false | null | true | match reads with
| [] -> ()
| x :: xs -> lemma_disjoint_implies_unchanged_at xs changes s1 s2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_disjoint_implies_unchanged_at",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Transformers.Locations.disjoint_locat... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_disjoint_implies_unchanged_at (reads changes: list location) (s1 s2: machine_state)
: Lemma (requires (!!(disjoint_locations reads changes) /\ unchanged_except changes s1 s2))
(ensures (unchanged_at reads s1 s2)) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_disjoint_implies_unchanged_at | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
reads: Prims.list Vale.Transformers.Locations.location ->
changes: Prims.list Vale.Transformers.Locations.location ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
!!(Vale.Transformers.Locations.disjo... | {
"end_col": 56,
"end_line": 573,
"start_col": 2,
"start_line": 570
} |
Prims.Tot | val code_exchange_allowed (c1 c2: safely_bounded_code) : pbool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let code_exchange_allowed (c1 c2:safely_bounded_code) : pbool =
rw_exchange_allowed (rw_set_of_code c1) (rw_set_of_code c2)
/+> normal (" for instructions " ^ fst (print_code c1 0 gcc) ^ " and " ^ fst (print_code c2 0 gcc)) | val code_exchange_allowed (c1 c2: safely_bounded_code) : pbool
let code_exchange_allowed (c1 c2: safely_bounded_code) : pbool = | false | null | false | rw_exchange_allowed (rw_set_of_code c1) (rw_set_of_code c2) /+>
normal (" for instructions " ^ fst (print_code c1 0 gcc) ^ " and " ^ fst (print_code c2 0 gcc)) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_code",
"Vale.Def.PossiblyMonad.op_Slash_Plus_Greater",
"Vale.Transformers.InstructionReorder.rw_exchange_allowed",
"Vale.Transformers.InstructionReorder.rw_set_of_code",
"Vale.X64.Instruction_s.normal",
"Prims.string",
"Prims.op_Hat",
"FStar.Pervasi... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val code_exchange_allowed (c1 c2: safely_bounded_code) : pbool | [] | Vale.Transformers.InstructionReorder.code_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.InstructionReorder.safely_bounded_code ->
c2: Vale.Transformers.InstructionReorder.safely_bounded_code
-> Vale.Def.PossiblyMonad.pbool | {
"end_col": 101,
"end_line": 1451,
"start_col": 2,
"start_line": 1450
} |
Prims.Tot | val find_transformation_hints (c1 c2: codes)
: Tot (possibly transformation_hints) (decreases %[metric_for_codes c2;metric_for_codes c1]) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec find_transformation_hints (c1 c2:codes) :
Tot (possibly transformation_hints)
(decreases %[metric_for_codes c2; metric_for_codes c1]) =
let e1, e2 = is_empty_codes c1, is_empty_codes c2 in
if e1 && e2 then (
return []
) else if e2 then (
Err ("non empty first code: " ^ fst (print_code (Block... | val find_transformation_hints (c1 c2: codes)
: Tot (possibly transformation_hints) (decreases %[metric_for_codes c2;metric_for_codes c1])
let rec find_transformation_hints (c1 c2: codes)
: Tot (possibly transformation_hints) (decreases %[metric_for_codes c2;metric_for_codes c1]) = | false | null | false | let e1, e2 = is_empty_codes c1, is_empty_codes c2 in
if e1 && e2
then (return [])
else
if e2
then (Err ("non empty first code: " ^ fst (print_code (Block c1) 0 gcc)))
else
if e1
then (Err ("non empty second code: " ^ fst (print_code (Block c2) 0 gcc)))
else
(let h1 :: t1 = c1 in
let h2 :... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total",
""
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.bool",
"Prims.op_AmpAmp",
"Vale.Def.PossiblyMonad.return",
"Vale.Transformers.InstructionReorder.transformation_hints",
"Prims.Nil",
"Vale.Transformers.InstructionReorder.transformation_hint",
"Vale.Def.PossiblyMonad.Err",
"Prims.op_Hat",
"FStar.Pervasi... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val find_transformation_hints (c1 c2: codes)
: Tot (possibly transformation_hints) (decreases %[metric_for_codes c2;metric_for_codes c1]) | [
"recursion"
] | Vale.Transformers.InstructionReorder.find_transformation_hints | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c1: Vale.X64.Machine_Semantics_s.codes -> c2: Vale.X64.Machine_Semantics_s.codes
-> Prims.Tot
(Vale.Def.PossiblyMonad.possibly Vale.Transformers.InstructionReorder.transformation_hints) | {
"end_col": 3,
"end_line": 1881,
"start_col": 61,
"start_line": 1798
} |
FStar.Pervasives.Lemma | val lemma_instr_apply_eval_args_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(f: instr_args_t outs args)
(oprs: instr_operands_t_args args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_args outs args f oprs s... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_instr_apply_eval_args_equiv_states
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(s1 s2:machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
(instr_apply_eval_args outs args f oprs s1) ==
(ins... | val lemma_instr_apply_eval_args_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(f: instr_args_t outs args)
(oprs: instr_operands_t_args args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_args outs args f oprs s... | false | null | true | match args with
| [] -> ()
| i :: args ->
let v, oprs:option (instr_val_t i) & _ =
match i with
| IOpEx i ->
let oprs = coerce oprs in
(instr_eval_operand_explicit i (fst oprs) s1, snd oprs)
| IOpIm i -> (instr_eval_operand_implicit i s1, coerce oprs)
in
let f:arrow (instr_val_t i) (instr_... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.instr_args_t",
"Vale.X64.Instruction_s.instr_operands_t_args",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.option",
"Vale.X64.Instruction_s.instr_val_t",
"Vale... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_instr_apply_eval_args_equiv_states
(outs: list instr_out)
(args: list instr_operand)
(f: instr_args_t outs args)
(oprs: instr_operands_t_args args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_args outs args f oprs s... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_instr_apply_eval_args_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
outs: Prims.list Vale.X64.Instruction_s.instr_out ->
args: Prims.list Vale.X64.Instruction_s.instr_operand ->
f: Vale.X64.Instruction_s.instr_args_t outs args ->
oprs: Vale.X64.Instruction_s.instr_operands_t_args args ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Sem... | {
"end_col": 73,
"end_line": 218,
"start_col": 2,
"start_line": 206
} |
FStar.Pervasives.Lemma | val lemma_disjoint_location_from_locations_mem1 (a: location) (as0: locations)
: Lemma (requires (not (L.mem a as0))) (ensures (!!(disjoint_location_from_locations a as0))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_disjoint_location_from_locations_mem1 (a:location) (as0:locations) :
Lemma
(requires (not (L.mem a as0)))
(ensures (!!(disjoint_location_from_locations a as0))) =
match as0 with
| [] -> ()
| x :: xs -> lemma_disjoint_location_from_locations_mem1 a xs | val lemma_disjoint_location_from_locations_mem1 (a: location) (as0: locations)
: Lemma (requires (not (L.mem a as0))) (ensures (!!(disjoint_location_from_locations a as0)))
let rec lemma_disjoint_location_from_locations_mem1 (a: location) (as0: locations)
: Lemma (requires (not (L.mem a as0))) (ensures (!!(disj... | false | null | true | match as0 with
| [] -> ()
| x :: xs -> lemma_disjoint_location_from_locations_mem1 a xs | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.Locations.location",
"Vale.Transformers.Locations.locations",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem1",
"Prims.unit",
"Prims.b2t",
"Prims.op_Negation",
"FStar.List.Tot.Base.mem",
"Prims.squash",
"Vale.Def.PossiblyMonad.op_B... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_disjoint_location_from_locations_mem1 (a: location) (as0: locations)
: Lemma (requires (not (L.mem a as0))) (ensures (!!(disjoint_location_from_locations a as0))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem1 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Transformers.Locations.location -> as0: Vale.Transformers.Locations.locations
-> FStar.Pervasives.Lemma (requires Prims.op_Negation (FStar.List.Tot.Base.mem a as0))
(ensures !!(Vale.Transformers.Locations.disjoint_location_from_locations a as0)) | {
"end_col": 63,
"end_line": 650,
"start_col": 2,
"start_line": 648
} |
FStar.Pervasives.Lemma | val lemma_constant_on_execution_mem
(locv: locations_with_values)
(f: st unit)
(s: machine_state)
(l: location_eq)
(v: location_val_eqt l)
: Lemma
(requires ((constant_on_execution locv f s) /\ ((run f s).ms_ok) /\ ((| l, v |) `L.mem` locv))
) (ensures ((eval_location l (ru... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_constant_on_execution_mem
(locv:locations_with_values) (f:st unit) (s:machine_state)
(l:location_eq) (v:location_val_eqt l) :
Lemma
(requires (
(constant_on_execution locv f s) /\
((run f s).ms_ok) /\
((| l, v |) `L.mem` locv)))
(ensures (
(eval_location l... | val lemma_constant_on_execution_mem
(locv: locations_with_values)
(f: st unit)
(s: machine_state)
(l: location_eq)
(v: location_val_eqt l)
: Lemma
(requires ((constant_on_execution locv f s) /\ ((run f s).ms_ok) /\ ((| l, v |) `L.mem` locv))
) (ensures ((eval_location l (ru... | false | null | true | match locv with
| [_] -> ()
| x :: xs -> if x = (| l, v |) then () else (lemma_constant_on_execution_mem xs f s l v) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.Locations.location_eq",
"Vale.Transformers.Locations.location_val_eqt",
"Vale.Transformers.BoundedInstructionEffects.loca... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val lemma_constant_on_execution_mem
(locv: locations_with_values)
(f: st unit)
(s: machine_state)
(l: location_eq)
(v: location_val_eqt l)
: Lemma
(requires ((constant_on_execution locv f s) /\ ((run f s).ms_ok) /\ ((| l, v |) `L.mem` locv))
) (ensures ((eval_location l (ru... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_constant_on_execution_mem | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
locv: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
f: Vale.X64.Machine_Semantics_s.st Prims.unit ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
l: Vale.Transformers.Locations.location_eq ->
v: Vale.Transformers.Locations.location_val_eqt l
-> FStar.Pervasives.Lemma
... | {
"end_col": 5,
"end_line": 641,
"start_col": 2,
"start_line": 636
} |
FStar.Pervasives.Lemma | val lemma_instr_write_output_implicit_equiv_states
(i: instr_operand_implicit)
(v: instr_val_t (IOpIm i))
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_write_output_implicit i v s_orig... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_instr_write_output_implicit_equiv_states
(i:instr_operand_implicit) (v:instr_val_t (IOpIm i))
(s_orig1 s1 s_orig2 s2:machine_state) :
Lemma
(requires (
(equiv_states s_orig1 s_orig2) /\
(equiv_states s1 s2)))
(ensures (
(equiv_states
(instr_write_output_imp... | val lemma_instr_write_output_implicit_equiv_states
(i: instr_operand_implicit)
(v: instr_val_t (IOpIm i))
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_write_output_implicit i v s_orig... | false | null | true | let snew1, snew2 =
(instr_write_output_implicit i v s_orig1 s1), (instr_write_output_implicit i v s_orig2 s2)
in
assert (equiv_states_ext snew1 snew2) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Instruction_s.instr_operand_implicit",
"Vale.X64.Instruction_s.instr_val_t",
"Vale.X64.Instruction_s.IOpIm",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims._assert",
"Vale.Transformers.InstructionReorder.equiv_states_ext",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervas... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"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_el... | null | val lemma_instr_write_output_implicit_equiv_states
(i: instr_operand_implicit)
(v: instr_val_t (IOpIm i))
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
((equiv_states (instr_write_output_implicit i v s_orig... | [] | Vale.Transformers.InstructionReorder.lemma_instr_write_output_implicit_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Instruction_s.instr_operand_implicit ->
v: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpIm i) ->
s_orig1: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s_orig2: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.... | {
"end_col": 39,
"end_line": 269,
"start_col": 60,
"start_line": 265
} |
Prims.Tot | val eq_ins (i1 i2: ins) : bool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let eq_ins (i1 i2:ins) : bool =
print_ins i1 gcc = print_ins i2 gcc | val eq_ins (i1 i2: ins) : bool
let eq_ins (i1 i2: ins) : bool = | false | null | false | print_ins i1 gcc = print_ins i2 gcc | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Prims.op_Equality",
"Prims.string",
"Vale.X64.Print_s.print_ins",
"Vale.X64.Print_s.gcc",
"Prims.bool"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val eq_ins (i1 i2: ins) : bool | [] | Vale.Transformers.InstructionReorder.eq_ins | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i1: Vale.X64.Machine_Semantics_s.ins -> i2: Vale.X64.Machine_Semantics_s.ins -> Prims.bool | {
"end_col": 37,
"end_line": 1695,
"start_col": 2,
"start_line": 1695
} |
FStar.Pervasives.Lemma | val lemma_eval_instr_equiv_states
(it: instr_t_record)
(oprs: instr_operands_t it.outs it.args)
(ann: instr_annotation it)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_ostates (eval_instr it oprs ann s1) (eval_instr it oprs ann s2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_eval_instr_equiv_states
(it:instr_t_record) (oprs:instr_operands_t it.outs it.args) (ann:instr_annotation it)
(s1 s2:machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
equiv_ostates
(eval_instr it oprs ann s1)
(eval_instr it oprs ann s2))) =
let I... | val lemma_eval_instr_equiv_states
(it: instr_t_record)
(oprs: instr_operands_t it.outs it.args)
(ann: instr_annotation it)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_ostates (eval_instr it oprs ann s1) (eval_instr it oprs ann s2)))
let lemma_eval_ins... | false | null | true | let InstrTypeRecord #outs #args #havoc_flags' i = it in
let vs1 = instr_apply_eval outs args (instr_eval i) oprs s1 in
let vs2 = instr_apply_eval outs args (instr_eval i) oprs s2 in
lemma_instr_apply_eval_inouts_equiv_states outs outs args (instr_eval i) oprs s1 s2;
assert (vs1 == vs2);
let s1_new =
match havoc_flags... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Machine_Semantics_s.machine_state",
"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_eval_instr_equiv_states
(it: instr_t_record)
(oprs: instr_operands_t it.outs it.args)
(ann: instr_annotation it)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_ostates (eval_instr it oprs ann s1) (eval_instr it oprs ann s2))) | [] | Vale.Transformers.InstructionReorder.lemma_eval_instr_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
it: Vale.X64.Instruction_s.instr_t_record ->
oprs:
Vale.X64.Instruction_s.instr_operands_t (InstrTypeRecord?.outs it) (InstrTypeRecord?.args it) ->
ann: Vale.X64.Machine_Semantics_s.instr_annotation it ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machi... | {
"end_col": 80,
"end_line": 357,
"start_col": 41,
"start_line": 333
} |
FStar.Pervasives.Lemma | val lemma_unchanged_at_mem (as0: list location) (a: location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (L.mem a as0)))
(ensures ((eval_location a s1 == eval_location a s2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_unchanged_at_mem (as0:list location) (a:location) (s1 s2:machine_state) :
Lemma
(requires (
(unchanged_at as0 s1 s2) /\
(L.mem a as0)))
(ensures (
(eval_location a s1 == eval_location a s2))) =
match as0 with
| [_] -> ()
| x :: xs ->
if a = x then () else
le... | val lemma_unchanged_at_mem (as0: list location) (a: location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (L.mem a as0)))
(ensures ((eval_location a s1 == eval_location a s2)))
let rec lemma_unchanged_at_mem (as0: list location) (a: location) (s1 s2: machine_state)
: Lemma (requi... | false | null | true | match as0 with
| [_] -> ()
| x :: xs -> if a = x then () else lemma_unchanged_at_mem xs a s1 s2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_Equality",
"Prims.bool",
"Vale.Transformers.InstructionReorder.lemma_unchanged_at_mem",
"Prims.unit",
"Prims.l_and",
"Vale.Transformers.BoundedInstructionEffects.unchanged_at",
"Prims.b2t"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val lemma_unchanged_at_mem (as0: list location) (a: location) (s1 s2: machine_state)
: Lemma (requires ((unchanged_at as0 s1 s2) /\ (L.mem a as0)))
(ensures ((eval_location a s1 == eval_location a s2))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_unchanged_at_mem | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
as0: Prims.list Vale.Transformers.Locations.location ->
a: Vale.Transformers.Locations.location ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
Vale.Transformers.BoundedInstructionEffects.unchanged_a... | {
"end_col": 37,
"end_line": 708,
"start_col": 2,
"start_line": 704
} |
FStar.Pervasives.Lemma | val lemma_equiv_states_when_except_none (s1 s2: machine_state) (ok: bool)
: Lemma (requires ((unchanged_except [] s1 s2)))
(ensures ((equiv_states ({ s1 with ms_ok = ok }) ({ s2 with ms_ok = ok })))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_equiv_states_when_except_none (s1 s2:machine_state) (ok:bool) :
Lemma
(requires (
(unchanged_except [] s1 s2)))
(ensures (
(equiv_states ({s1 with ms_ok=ok}) ({s2 with ms_ok=ok})))) =
assert_norm (cf s2.ms_flags == cf (filter_state s2 s1.ms_flags ok []).ms_flags); (* OBSERVE *)
a... | val lemma_equiv_states_when_except_none (s1 s2: machine_state) (ok: bool)
: Lemma (requires ((unchanged_except [] s1 s2)))
(ensures ((equiv_states ({ s1 with ms_ok = ok }) ({ s2 with ms_ok = ok }))))
let lemma_equiv_states_when_except_none (s1 s2: machine_state) (ok: bool)
: Lemma (requires ((unchanged_ex... | false | null | true | assert_norm (cf s2.ms_flags == cf (filter_state s2 s1.ms_flags ok []).ms_flags);
assert_norm (overflow s2.ms_flags == overflow (filter_state s2 s1.ms_flags ok []).ms_flags);
lemma_locations_complete s1 s2 s1.ms_flags ok [] | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.bool",
"Vale.Transformers.Locations.lemma_locations_complete",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Prims.Nil",
"Vale.X64.Machine_s.observation",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Val... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_equiv_states_when_except_none (s1 s2: machine_state) (ok: bool)
: Lemma (requires ((unchanged_except [] s1 s2)))
(ensures ((equiv_states ({ s1 with ms_ok = ok }) ({ s2 with ms_ok = ok })))) | [] | Vale.Transformers.InstructionReorder.lemma_equiv_states_when_except_none | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state ->
ok: Prims.bool
-> FStar.Pervasives.Lemma
(requires Vale.Transformers.BoundedInstructionEffects.unchanged_except [] s1 s2)
(ensures
Vale.Transformers.InstructionReorder.equiv_states (Val... | {
"end_col": 50,
"end_line": 813,
"start_col": 2,
"start_line": 811
} |
FStar.Pervasives.Lemma | val lemma_mem_not_disjoint (a: location) (as1 as2: list location)
: Lemma (requires (L.mem a as1 /\ L.mem a as2)) (ensures ((not !!(disjoint_locations as1 as2)))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_mem_not_disjoint (a:location) (as1 as2:list location) :
Lemma
(requires (L.mem a as1 /\ L.mem a as2))
(ensures (
(not !!(disjoint_locations as1 as2)))) =
match as1, as2 with
| [_], [_] -> ()
| [_], y :: ys ->
if a = y then () else (
lemma_mem_not_disjoint a as1 ys
)
... | val lemma_mem_not_disjoint (a: location) (as1 as2: list location)
: Lemma (requires (L.mem a as1 /\ L.mem a as2)) (ensures ((not !!(disjoint_locations as1 as2))))
let rec lemma_mem_not_disjoint (a: location) (as1 as2: list location)
: Lemma (requires (L.mem a as1 /\ L.mem a as2)) (ensures ((not !!(disjoint_loca... | false | null | true | match as1, as2 with
| [_], [_] -> ()
| [_], y :: ys -> if a = y then () else (lemma_mem_not_disjoint a as1 ys)
| x :: xs, y :: ys ->
if a = x
then
(if a = y
then ()
else
(lemma_mem_not_disjoint a as1 ys;
lemma_disjoint_locations_symmetric as1 as2;
lemma_disjoint_locations... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.Locations.location",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Equality",
"Prims.bool",
"Vale.Transformers.InstructionReorder.lemma_mem_not_disjoint",
"Prims.unit",
"Vale.Transformers.Locations.lemma_disjoint_locations_symmetric",
"Prims.l_and",
"Prims.b2t",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val lemma_mem_not_disjoint (a: location) (as1 as2: list location)
: Lemma (requires (L.mem a as1 /\ L.mem a as2)) (ensures ((not !!(disjoint_locations as1 as2)))) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_mem_not_disjoint | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Vale.Transformers.Locations.location ->
as1: Prims.list Vale.Transformers.Locations.location ->
as2: Prims.list Vale.Transformers.Locations.location
-> FStar.Pervasives.Lemma
(requires FStar.List.Tot.Base.mem a as1 /\ FStar.List.Tot.Base.mem a as2)
(ensures Prims.op_Negation !!(Vale.Transf... | {
"end_col": 5,
"end_line": 836,
"start_col": 2,
"start_line": 821
} |
Prims.Tot | val value_of_const_loc
(lv: locations_with_values)
(l: location_eq{L.mem l (locations_of_locations_with_values lv)})
: location_val_eqt l | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec value_of_const_loc (lv:locations_with_values) (l:location_eq{
L.mem l (locations_of_locations_with_values lv)
}) : location_val_eqt l =
let x :: xs = lv in
if dfst x = l then dsnd x else value_of_const_loc xs l | val value_of_const_loc
(lv: locations_with_values)
(l: location_eq{L.mem l (locations_of_locations_with_values lv)})
: location_val_eqt l
let rec value_of_const_loc
(lv: locations_with_values)
(l: location_eq{L.mem l (locations_of_locations_with_values lv)})
: location_val_eqt l = | false | null | false | let x :: xs = lv in
if dfst x = l then dsnd x else value_of_const_loc xs l | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.Transformers.Locations.location_eq",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Vale.Transformers.Locations.location",
"Vale.Transformers.InstructionReorder.locations_of_locations_with_values",
"Vale.Transformers.BoundedInstruction... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val value_of_const_loc
(lv: locations_with_values)
(l: location_eq{L.mem l (locations_of_locations_with_values lv)})
: location_val_eqt l | [
"recursion"
] | Vale.Transformers.InstructionReorder.value_of_const_loc | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
lv: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
l:
Vale.Transformers.Locations.location_eq
{ FStar.List.Tot.Base.mem l
(Vale.Transformers.InstructionReorder.locations_of_locations_with_values lv) }
-> Vale.Transformers.Locations.location_val_eqt l | {
"end_col": 56,
"end_line": 656,
"start_col": 27,
"start_line": 654
} |
FStar.Pervasives.Lemma | val lemma_unchanged_at_combine
(a1 a2: locations)
(c1 c2: locations_with_values)
(sa1 sa2 sb1 sb2: machine_state)
: Lemma
(requires
(!!(write_exchange_allowed a1 a2 c1 c2) /\
(unchanged_at (locations_of_locations_with_values c1) sb1 sb2) /\
(unchanged_at (location... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_unchanged_at_combine (a1 a2:locations) (c1 c2:locations_with_values) (sa1 sa2 sb1 sb2:machine_state) :
Lemma
(requires (
!!(write_exchange_allowed a1 a2 c1 c2) /\
(unchanged_at (locations_of_locations_with_values c1) sb1 sb2) /\
(unchanged_at (locations_of_locations_with_values c... | val lemma_unchanged_at_combine
(a1 a2: locations)
(c1 c2: locations_with_values)
(sa1 sa2 sb1 sb2: machine_state)
: Lemma
(requires
(!!(write_exchange_allowed a1 a2 c1 c2) /\
(unchanged_at (locations_of_locations_with_values c1) sb1 sb2) /\
(unchanged_at (location... | false | null | true | let precond =
!!(write_exchange_allowed a1 a2 c1 c2) /\
(unchanged_at (locations_of_locations_with_values c1) sb1 sb2) /\
(unchanged_at (locations_of_locations_with_values c2) sb1 sb2) /\ (unchanged_at a1 sa1 sb2) /\
(unchanged_except a2 sa1 sb1) /\ (unchanged_at a2 sa2 sb1) /\ (unchanged_except a1 sa2 sb2)
in
... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.Locations.locations",
"Vale.Transformers.BoundedInstructionEffects.locations_with_values",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.Nil",
"Vale.Transformers.Locations.location",
"Prims.list",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_unchanged_at_combine
(a1 a2: locations)
(c1 c2: locations_with_values)
(sa1 sa2 sb1 sb2: machine_state)
: Lemma
(requires
(!!(write_exchange_allowed a1 a2 c1 c2) /\
(unchanged_at (locations_of_locations_with_values c1) sb1 sb2) /\
(unchanged_at (location... | [] | Vale.Transformers.InstructionReorder.lemma_unchanged_at_combine | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a1: Vale.Transformers.Locations.locations ->
a2: Vale.Transformers.Locations.locations ->
c1: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
c2: Vale.Transformers.BoundedInstructionEffects.locations_with_values ->
sa1: Vale.X64.Machine_Semantics_s.machine_state ->
sa2: Val... | {
"end_col": 17,
"end_line": 783,
"start_col": 53,
"start_line": 722
} |
FStar.Pervasives.Lemma | val lemma_instr_apply_eval_inouts_equiv_states
(outs inouts: list instr_out)
(args: list instr_operand)
(f: instr_inouts_t outs inouts args)
(oprs: instr_operands_t inouts args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_ino... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_instr_apply_eval_inouts_equiv_states
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(s1 s2:machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
(instr_apply_eval_inouts outs inouts ar... | val lemma_instr_apply_eval_inouts_equiv_states
(outs inouts: list instr_out)
(args: list instr_operand)
(f: instr_inouts_t outs inouts args)
(oprs: instr_operands_t inouts args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_ino... | false | null | true | match inouts with
| [] -> lemma_instr_apply_eval_args_equiv_states outs args f oprs s1 s2
| (Out, i) :: inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_instr_apply_eval_inouts_equiv_states outs inouts args (coerce f) oprs s1 s2
| ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.instr_inouts_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_instr_apply_eval_args_equiv_states",
"... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_instr_apply_eval_inouts_equiv_states
(outs inouts: list instr_out)
(args: list instr_operand)
(f: instr_inouts_t outs inouts args)
(oprs: instr_operands_t inouts args)
(s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
((instr_apply_eval_ino... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_instr_apply_eval_inouts_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
outs: Prims.list Vale.X64.Instruction_s.instr_out ->
inouts: Prims.list Vale.X64.Instruction_s.instr_out ->
args: Prims.list Vale.X64.Instruction_s.instr_operand ->
f: Vale.X64.Instruction_s.instr_inouts_t outs inouts args ->
oprs: Vale.X64.Instruction_s.instr_operands_t inouts args ->
s1: Vale... | {
"end_col": 82,
"end_line": 250,
"start_col": 2,
"start_line": 230
} |
FStar.Pervasives.Lemma | val lemma_instruction_exchange' (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (machine_eval_ins i1 s1),
machine_eval_ins i1 (machine_eval_ins i2 s2)
i... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_instruction_exchange' (i1 i2 : ins) (s1 s2 : machine_state) :
Lemma
(requires (
!!(ins_exchange_allowed i1 i2) /\
(equiv_states s1 s2)))
(ensures (
(let s1', s2' =
machine_eval_ins i2 (machine_eval_ins i1 s1),
machine_eval_ins i1 (machine_eval_ins i2 s2)... | val lemma_instruction_exchange' (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (machine_eval_ins i1 s1),
machine_eval_ins i1 (machine_eval_ins i2 s2)
i... | false | null | true | lemma_machine_eval_ins_st_exchange i1 i2 s1;
lemma_eval_ins_equiv_states i2 s1 s2;
lemma_eval_ins_equiv_states i1 (machine_eval_ins i2 s1) (machine_eval_ins i2 s2) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_eval_ins_equiv_states",
"Vale.X64.Machine_Semantics_s.machine_eval_ins",
"Prims.unit",
"Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_st_exchange",
"Prims.l_and",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_instruction_exchange' (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (machine_eval_ins i1 s1),
machine_eval_ins i1 (machine_eval_ins i2 s2)
i... | [] | Vale.Transformers.InstructionReorder.lemma_instruction_exchange' | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i1: Vale.X64.Machine_Semantics_s.ins ->
i2: Vale.X64.Machine_Semantics_s.ins ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
!!(Vale.Transformers.InstructionReorder.ins_exchange_allowed i1 i2) /\
... | {
"end_col": 82,
"end_line": 1116,
"start_col": 2,
"start_line": 1114
} |
FStar.Pervasives.Lemma | val lemma_instruction_exchange (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (filt_state (machine_eval_ins i1 (filt_state s1))),
machine_eval_ins i1 (filt_state (... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_instruction_exchange (i1 i2 : ins) (s1 s2 : machine_state) :
Lemma
(requires (
!!(ins_exchange_allowed i1 i2) /\
(equiv_states s1 s2)))
(ensures (
(let s1', s2' =
machine_eval_ins i2 (filt_state (machine_eval_ins i1 (filt_state s1))),
machine_eval_ins i1... | val lemma_instruction_exchange (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (filt_state (machine_eval_ins i1 (filt_state s1))),
machine_eval_ins i1 (filt_state (... | false | null | true | lemma_eval_ins_equiv_states i1 s1 (filt_state s1);
lemma_eval_ins_equiv_states i2 s2 (filt_state s2);
lemma_eval_ins_equiv_states i2
(machine_eval_ins i1 (filt_state s1))
(filt_state (machine_eval_ins i1 (filt_state s1)));
lemma_eval_ins_equiv_states i1
(machine_eval_ins i2 (filt_state s2))
(filt_state (machine... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.InstructionReorder.lemma_instruction_exchange'",
"Prims.unit",
"Vale.Transformers.InstructionReorder.lemma_eval_ins_equiv_states",
"Vale.X64.Machine_Semantics_s.machine_eval_ins",
"Vale.Transformers.Inst... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_instruction_exchange (i1 i2: ins) (s1 s2: machine_state)
: Lemma (requires (!!(ins_exchange_allowed i1 i2) /\ (equiv_states s1 s2)))
(ensures
((let s1', s2' =
machine_eval_ins i2 (filt_state (machine_eval_ins i1 (filt_state s1))),
machine_eval_ins i1 (filt_state (... | [] | Vale.Transformers.InstructionReorder.lemma_instruction_exchange | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i1: Vale.X64.Machine_Semantics_s.ins ->
i2: Vale.X64.Machine_Semantics_s.ins ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
!!(Vale.Transformers.InstructionReorder.ins_exchange_allowed i1 i2) /\
... | {
"end_col": 41,
"end_line": 1134,
"start_col": 2,
"start_line": 1128
} |
FStar.Pervasives.Lemma | val lemma_machine_eval_ins_bounded_effects (i: safely_bounded_ins)
: Lemma (ensures (bounded_effects (rw_set_of_ins i) (wrap_ss (machine_eval_ins i)))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_machine_eval_ins_bounded_effects (i:safely_bounded_ins) :
Lemma
(ensures (bounded_effects (rw_set_of_ins i) (wrap_ss (machine_eval_ins i)))) =
lemma_machine_eval_ins_st_bounded_effects i;
lemma_feq_bounded_effects (rw_set_of_ins i) (machine_eval_ins_st i) (wrap_ss (machine_eval_ins i)) | val lemma_machine_eval_ins_bounded_effects (i: safely_bounded_ins)
: Lemma (ensures (bounded_effects (rw_set_of_ins i) (wrap_ss (machine_eval_ins i))))
let lemma_machine_eval_ins_bounded_effects (i: safely_bounded_ins)
: Lemma (ensures (bounded_effects (rw_set_of_ins i) (wrap_ss (machine_eval_ins i)))) = | false | null | true | lemma_machine_eval_ins_st_bounded_effects i;
lemma_feq_bounded_effects (rw_set_of_ins i) (machine_eval_ins_st i) (wrap_ss (machine_eval_ins i)) | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_ins",
"Vale.Transformers.InstructionReorder.lemma_feq_bounded_effects",
"Vale.Transformers.BoundedInstructionEffects.rw_set_of_ins",
"Vale.X64.Machine_Semantics_s.machine_eval_ins_st",
"Vale.Transformers.InstructionReorder.wrap_ss",
"Vale.X64.Machine_Se... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_machine_eval_ins_bounded_effects (i: safely_bounded_ins)
: Lemma (ensures (bounded_effects (rw_set_of_ins i) (wrap_ss (machine_eval_ins i)))) | [] | Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_bounded_effects | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Vale.Transformers.InstructionReorder.safely_bounded_ins
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.BoundedInstructionEffects.bounded_effects (Vale.Transformers.BoundedInstructionEffects.rw_set_of_ins
i)
(Vale.Transformers.InstructionReorder.wrap_ss (Vale.X64.Machine_Semantic... | {
"end_col": 100,
"end_line": 1090,
"start_col": 2,
"start_line": 1089
} |
FStar.Pervasives.Lemma | val lemma_commute (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures (equiv_states_or_both_not_ok (run2 f1 f2 s) (run2 f2 f1 s))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_commute (f1 f2:st unit) (rw1 rw2:rw_set) (s:machine_state) :
Lemma
(requires (
(bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\
!!(rw_exchange_allowed rw1 rw2)))
(ensures (
equiv_states_or_both_not_ok
(run2 f1 f2 s)
(run2 f2 f1 s))) =
let ... | val lemma_commute (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures (equiv_states_or_both_not_ok (run2 f1 f2 s) (run2 f2 f1 s)))
let lemma_commute (f1 f2: st unit) (rw1 rw2: ... | false | null | true | let s12 = run2 f1 f2 s in
let s21 = run2 f2 f1 s in
if not s12.ms_ok || not s21.ms_ok
then (lemma_both_not_ok f1 f2 rw1 rw2 s)
else
(let s1 = run f1 s in
let s2 = run f2 s in
let r1, w1, c1 = rw1.loc_reads, rw1.loc_writes, rw1.loc_constant_writes in
let r2, w2, c2 = rw2.loc_reads, rw2.loc_writes, rw2.loc_... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_BarBar",
"Prims.op_Negation",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.Transformers.InstructionReorder.lemma_... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_commute (f1 f2: st unit) (rw1 rw2: rw_set) (s: machine_state)
: Lemma
(requires
((bounded_effects rw1 f1) /\ (bounded_effects rw2 f2) /\ !!(rw_exchange_allowed rw1 rw2)))
(ensures (equiv_states_or_both_not_ok (run2 f1 f2 s) (run2 f2 f1 s))) | [] | Vale.Transformers.InstructionReorder.lemma_commute | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit ->
rw1: Vale.Transformers.BoundedInstructionEffects.rw_set ->
rw2: Vale.Transformers.BoundedInstructionEffects.rw_set ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(... | {
"end_col": 3,
"end_line": 1025,
"start_col": 28,
"start_line": 991
} |
Prims.Tot | val split3: #a:Type -> l:list a -> i:nat{i < L.length l} -> Tot (list a * a * list a) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let split3 #a l i =
let a, as0 = L.splitAt i l in
L.lemma_splitAt_snd_length i l;
let b :: c = as0 in
a, b, c | val split3: #a:Type -> l:list a -> i:nat{i < L.length l} -> Tot (list a * a * list a)
let split3 #a l i = | false | null | false | let a, as0 = L.splitAt i l in
L.lemma_splitAt_snd_length i l;
let b :: c = as0 in
a, b, c | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Pervasives.Native.tuple3",
"Prims.unit",
"FStar.List.Tot.Base.lemma_splitAt_snd_length",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val split3: #a:Type -> l:list a -> i:nat{i < L.length l} -> Tot (list a * a * list a) | [] | Vale.Transformers.InstructionReorder.split3 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l: Prims.list a -> i: Prims.nat{i < FStar.List.Tot.Base.length l}
-> (Prims.list a * a) * Prims.list a | {
"end_col": 9,
"end_line": 1572,
"start_col": 19,
"start_line": 1568
} |
FStar.Pervasives.Lemma | val lemma_constant_on_execution_stays_constant
(f1 f2: st unit)
(rw1 rw2: rw_set)
(s s1 s2: machine_state)
: Lemma
(requires
(s1.ms_ok /\ s2.ms_ok /\ (run f1 s1).ms_ok /\ (run f2 s2).ms_ok /\ (bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\ (s1 == run f2 s) /\ (s2 ==... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_constant_on_execution_stays_constant (f1 f2:st unit) (rw1 rw2:rw_set) (s s1 s2:machine_state) :
Lemma
(requires (
s1.ms_ok /\ s2.ms_ok /\
(run f1 s1).ms_ok /\ (run f2 s2).ms_ok /\
(bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\
(s1 == run f2 s) /\
... | val lemma_constant_on_execution_stays_constant
(f1 f2: st unit)
(rw1 rw2: rw_set)
(s s1 s2: machine_state)
: Lemma
(requires
(s1.ms_ok /\ s2.ms_ok /\ (run f1 s1).ms_ok /\ (run f2 s2).ms_ok /\ (bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\ (s1 == run f2 s) /\ (s2 ==... | false | null | true | let precond =
s1.ms_ok /\ s2.ms_ok /\ (run f1 s1).ms_ok /\ (run f2 s2).ms_ok /\ (bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\ (s1 == run f2 s) /\ (s2 == run f1 s) /\
!!(write_exchange_allowed rw1.loc_writes
rw2.loc_writes
rw1.loc_constant_writes
rw2.loc_constant_writes)
in
let r1, w1, ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.st",
"Prims.unit",
"Vale.Transformers.BoundedInstructionEffects.rw_set",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Transformers.Locations.locations",
"Prims.list",
"Vale.Transformers.Locations.location",
"Vale.Transformers.BoundedInstructionEffects.location_with... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val lemma_constant_on_execution_stays_constant
(f1 f2: st unit)
(rw1 rw2: rw_set)
(s s1 s2: machine_state)
: Lemma
(requires
(s1.ms_ok /\ s2.ms_ok /\ (run f1 s1).ms_ok /\ (run f2 s2).ms_ok /\ (bounded_effects rw1 f1) /\
(bounded_effects rw2 f2) /\ (s1 == run f2 s) /\ (s2 ==... | [] | Vale.Transformers.InstructionReorder.lemma_constant_on_execution_stays_constant | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1: Vale.X64.Machine_Semantics_s.st Prims.unit ->
f2: Vale.X64.Machine_Semantics_s.st Prims.unit ->
rw1: Vale.Transformers.BoundedInstructionEffects.rw_set ->
rw2: Vale.Transformers.BoundedInstructionEffects.rw_set ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semanti... | {
"end_col": 12,
"end_line": 979,
"start_col": 25,
"start_line": 883
} |
Prims.Tot | val num_blocks_in_codes (c: codes) : nat | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec num_blocks_in_codes (c:codes) : nat =
match c with
| [] -> 0
| Block l :: t -> 1 + num_blocks_in_codes l + num_blocks_in_codes t
| _ :: t -> num_blocks_in_codes t | val num_blocks_in_codes (c: codes) : nat
let rec num_blocks_in_codes (c: codes) : nat = | false | null | false | match c with
| [] -> 0
| Block l :: t -> 1 + num_blocks_in_codes l + num_blocks_in_codes t
| _ :: t -> num_blocks_in_codes t | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Bytes_Code_s.code_t",
"Prims.op_Addition",
"Vale.Transformers.InstructionReorder.num_block... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val num_blocks_in_codes (c: codes) : nat | [
"recursion"
] | Vale.Transformers.InstructionReorder.num_blocks_in_codes | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c: Vale.X64.Machine_Semantics_s.codes -> Prims.nat | {
"end_col": 35,
"end_line": 1520,
"start_col": 2,
"start_line": 1517
} |
Prims.Tot | val wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec wrap_diveinat (p:nat) (l:transformation_hints) : transformation_hints =
match l with
| [] -> []
| x :: xs ->
DiveInAt p x :: wrap_diveinat p xs | val wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints
let rec wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints = | false | null | false | match l with
| [] -> []
| x :: xs -> DiveInAt p x :: wrap_diveinat p xs | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Prims.nat",
"Vale.Transformers.InstructionReorder.transformation_hints",
"Prims.Nil",
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.list",
"Prims.Cons",
"Vale.Transformers.InstructionReorder.DiveInAt",
"Vale.Transformers.InstructionReorder.wrap_diveinat"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints | [
"recursion"
] | Vale.Transformers.InstructionReorder.wrap_diveinat | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Prims.nat -> l: Vale.Transformers.InstructionReorder.transformation_hints
-> Vale.Transformers.InstructionReorder.transformation_hints | {
"end_col": 38,
"end_line": 1563,
"start_col": 2,
"start_line": 1560
} |
FStar.Pervasives.Lemma | val lemma_num_blocks_in_codes_append (c1 c2: codes)
: Lemma
(ensures
(num_blocks_in_codes (c1 `L.append` c2) == num_blocks_in_codes c1 + num_blocks_in_codes c2))
[SMTPat (num_blocks_in_codes (c1 `L.append` c2))] | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_num_blocks_in_codes_append (c1 c2:codes) :
Lemma
(ensures (num_blocks_in_codes (c1 `L.append` c2) == num_blocks_in_codes c1 + num_blocks_in_codes c2))
[SMTPat (num_blocks_in_codes (c1 `L.append` c2))] =
match c1 with
| [] -> ()
| x :: xs -> lemma_num_blocks_in_codes_append xs c2 | val lemma_num_blocks_in_codes_append (c1 c2: codes)
: Lemma
(ensures
(num_blocks_in_codes (c1 `L.append` c2) == num_blocks_in_codes c1 + num_blocks_in_codes c2))
[SMTPat (num_blocks_in_codes (c1 `L.append` c2))]
let rec lemma_num_blocks_in_codes_append (c1 c2: codes)
: Lemma
(ensures
... | false | null | true | match c1 with
| [] -> ()
| x :: xs -> lemma_num_blocks_in_codes_append xs c2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_num_blocks_in_codes_append",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Transformers... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_num_blocks_in_codes_append (c1 c2: codes)
: Lemma
(ensures
(num_blocks_in_codes (c1 `L.append` c2) == num_blocks_in_codes c1 + num_blocks_in_codes c2))
[SMTPat (num_blocks_in_codes (c1 `L.append` c2))] | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_num_blocks_in_codes_append | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c1: Vale.X64.Machine_Semantics_s.codes -> c2: Vale.X64.Machine_Semantics_s.codes
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.InstructionReorder.num_blocks_in_codes (c1 @ c2) ==
Vale.Transformers.InstructionReorder.num_blocks_in_codes c1 +
Vale.Transformers.InstructionReorder.num... | {
"end_col": 53,
"end_line": 1528,
"start_col": 2,
"start_line": 1526
} |
Prims.Tot | val bubble_to_top (cs: codes) (i: nat{i < L.length cs})
: possibly (cs':
codes
{ let a, b, c = L.split3 cs i in
cs' == L.append a c /\ L.length cs' = L.length cs - 1 }) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec bubble_to_top (cs:codes) (i:nat{i < L.length cs}) : possibly (cs':codes{
let a, b, c = L.split3 cs i in
cs' == L.append a c /\
L.length cs' = L.length cs - 1
}) =
match cs with
| [_] -> return []
| h :: t ->
if i = 0 then (
return t
) else (
let x = L.index cs i in
... | val bubble_to_top (cs: codes) (i: nat{i < L.length cs})
: possibly (cs':
codes
{ let a, b, c = L.split3 cs i in
cs' == L.append a c /\ L.length cs' = L.length cs - 1 })
let rec bubble_to_top (cs: codes) (i: nat{i < L.length cs})
: possibly (cs':
codes
{ let a, b, ... | false | null | false | match cs with
| [_] -> return []
| h :: t ->
if i = 0
then (return t)
else
(let x = L.index cs i in
if not (safely_bounded_code_p x)
then (Err ("Cannot safely move " ^ fst (print_code x 0 gcc)))
else
(if not (safely_bounded_code_p h)
then (Err ("Cannot safely move beyond " ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.Def.PossiblyMonad.return",
"FStar.List.Tot.Base.split3",
"Prims.list",
"Prims.l_and",
"Prims... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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_el... | null | val bubble_to_top (cs: codes) (i: nat{i < L.length cs})
: possibly (cs':
codes
{ let a, b, c = L.split3 cs i in
cs' == L.append a c /\ L.length cs' = L.length cs - 1 }) | [
"recursion"
] | Vale.Transformers.InstructionReorder.bubble_to_top | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | cs: Vale.X64.Machine_Semantics_s.codes -> i: Prims.nat{i < FStar.List.Tot.Base.length cs}
-> Vale.Def.PossiblyMonad.possibly (cs':
Vale.X64.Machine_Semantics_s.codes
{ let _ = FStar.List.Tot.Base.split3 cs i in
(let FStar.Pervasives.Native.Mktuple3 #_ #_ #_ a _ c = _ in
cs'... | {
"end_col": 5,
"end_line": 1513,
"start_col": 2,
"start_line": 1491
} |
Prims.Tot | val increment_hint (th: transformation_hint) : transformation_hint | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let increment_hint (th:transformation_hint) : transformation_hint =
match th with
| MoveUpFrom p -> MoveUpFrom (p + 1)
| DiveInAt p q -> DiveInAt (p + 1) q
| _ -> th | val increment_hint (th: transformation_hint) : transformation_hint
let increment_hint (th: transformation_hint) : transformation_hint = | false | null | false | match th with
| MoveUpFrom p -> MoveUpFrom (p + 1)
| DiveInAt p q -> DiveInAt (p + 1) q
| _ -> th | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.nat",
"Vale.Transformers.InstructionReorder.MoveUpFrom",
"Prims.op_Addition",
"Vale.Transformers.InstructionReorder.DiveInAt"
] | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val increment_hint (th: transformation_hint) : transformation_hint | [] | Vale.Transformers.InstructionReorder.increment_hint | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | th: Vale.Transformers.InstructionReorder.transformation_hint
-> Vale.Transformers.InstructionReorder.transformation_hint | {
"end_col": 11,
"end_line": 1730,
"start_col": 2,
"start_line": 1727
} |
FStar.Pervasives.Lemma | val lemma_code_exchange_allowed (c1 c2: safely_bounded_code) (fuel: nat) (s: machine_state)
: Lemma (requires (!!(code_exchange_allowed c1 c2)))
(ensures
(equiv_option_states (machine_eval_codes [c1; c2] fuel s)
(machine_eval_codes [c2; c1] fuel s))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_code_exchange_allowed (c1 c2:safely_bounded_code) (fuel:nat) (s:machine_state) :
Lemma
(requires (
!!(code_exchange_allowed c1 c2)))
(ensures (
equiv_option_states
(machine_eval_codes [c1; c2] fuel s)
(machine_eval_codes [c2; c1] fuel s))) =
lemma_bounded_code c... | val lemma_code_exchange_allowed (c1 c2: safely_bounded_code) (fuel: nat) (s: machine_state)
: Lemma (requires (!!(code_exchange_allowed c1 c2)))
(ensures
(equiv_option_states (machine_eval_codes [c1; c2] fuel s)
(machine_eval_codes [c2; c1] fuel s)))
let lemma_code_exchange_allowed (c1 c2:... | false | null | true | lemma_bounded_code c1 fuel;
lemma_bounded_code c2 fuel;
let f1 = wrap_sos (machine_eval_code c1 fuel) in
let f2 = wrap_sos (machine_eval_code c2 fuel) in
lemma_commute f1 f2 (rw_set_of_code c1) (rw_set_of_code c2) s;
assert (equiv_states_or_both_not_ok (run2 f1 f2 s) (run2 f2 f1 s));
let s1 = run f1 s in
let s12 = run ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Classical.move_requires",
"Prims.b2t",
"Prims.op_Negation",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.Transformers.InstructionReorder.erroring_... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 0,
"max_fuel": 3,
"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_el... | null | val lemma_code_exchange_allowed (c1 c2: safely_bounded_code) (fuel: nat) (s: machine_state)
: Lemma (requires (!!(code_exchange_allowed c1 c2)))
(ensures
(equiv_option_states (machine_eval_codes [c1; c2] fuel s)
(machine_eval_codes [c2; c1] fuel s))) | [] | Vale.Transformers.InstructionReorder.lemma_code_exchange_allowed | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.Transformers.InstructionReorder.safely_bounded_code ->
c2: Vale.Transformers.InstructionReorder.safely_bounded_code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires !!(Vale.Transformers.InstructionReorder.code_exchange_allowed c1 c... | {
"end_col": 77,
"end_line": 1478,
"start_col": 2,
"start_line": 1462
} |
Prims.Tot | val find_deep_code_transform (c: code) (cs: codes) : possibly transformation_hint | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec find_deep_code_transform (c:code) (cs:codes) : possibly transformation_hint =
match cs with
| [] ->
Err ("Not found (during find_deep_code_transform): " ^ fst (print_code c 0 gcc))
| x :: xs ->
(*
let _ = IO.debug_print_string (
"---------------------------------\n" ^
" c : \n"... | val find_deep_code_transform (c: code) (cs: codes) : possibly transformation_hint
let rec find_deep_code_transform (c: code) (cs: codes) : possibly transformation_hint = | false | null | false | match cs with
| [] -> Err ("Not found (during find_deep_code_transform): " ^ fst (print_code c 0 gcc))
| x :: xs ->
if is_empty_code x
then find_deep_code_transform c xs
else
(if eq_codes (fully_unblocked_code x) (fully_unblocked_code c)
then (return (MoveUpFrom 0))
else
(match x with
... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Def.PossiblyMonad.Err",
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.op_Hat",
"FStar.Pervasives.Native.fst",
"Prims.string",
"Prims.int",
"Vale.X64.Print_s.print_code",
"Vale.X64.Print_s.gcc",
... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | true | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val find_deep_code_transform (c: code) (cs: codes) : possibly transformation_hint | [
"recursion"
] | Vale.Transformers.InstructionReorder.find_deep_code_transform | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c: Vale.X64.Machine_Semantics_s.code -> cs: Vale.X64.Machine_Semantics_s.codes
-> Vale.Def.PossiblyMonad.possibly Vale.Transformers.InstructionReorder.transformation_hint | {
"end_col": 5,
"end_line": 1766,
"start_col": 2,
"start_line": 1733
} |
FStar.Pervasives.Lemma | val lemma_metric_for_codes_append (c1 c2: codes)
: Lemma
(ensures (metric_for_codes (c1 `L.append` c2) == metric_for_codes c1 + metric_for_codes c2))
[SMTPat (metric_for_codes (c1 `L.append` c2))] | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_metric_for_codes_append (c1 c2:codes) :
Lemma
(ensures (metric_for_codes (c1 `L.append` c2) == metric_for_codes c1 + metric_for_codes c2))
[SMTPat (metric_for_codes (c1 `L.append` c2))] =
match c1 with
| [] -> ()
| x :: xs -> lemma_metric_for_codes_append xs c2 | val lemma_metric_for_codes_append (c1 c2: codes)
: Lemma
(ensures (metric_for_codes (c1 `L.append` c2) == metric_for_codes c1 + metric_for_codes c2))
[SMTPat (metric_for_codes (c1 `L.append` c2))]
let rec lemma_metric_for_codes_append (c1 c2: codes)
: Lemma
(ensures (metric_for_codes (c1 `L.ap... | false | null | true | match c1 with
| [] -> ()
| x :: xs -> lemma_metric_for_codes_append xs c2 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_metric_for_codes_append",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Transformers.In... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"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_el... | null | val lemma_metric_for_codes_append (c1 c2: codes)
: Lemma
(ensures (metric_for_codes (c1 `L.append` c2) == metric_for_codes c1 + metric_for_codes c2))
[SMTPat (metric_for_codes (c1 `L.append` c2))] | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_metric_for_codes_append | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c1: Vale.X64.Machine_Semantics_s.codes -> c2: Vale.X64.Machine_Semantics_s.codes
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.InstructionReorder.metric_for_codes (c1 @ c2) ==
Vale.Transformers.InstructionReorder.metric_for_codes c1 +
Vale.Transformers.InstructionReorder.metric_fo... | {
"end_col": 50,
"end_line": 1788,
"start_col": 2,
"start_line": 1786
} |
FStar.Pervasives.Lemma | val lemma_machine_eval_codes_block_to_append (c1 c2: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(machine_eval_codes (c1 `L.append` c2) fuel s == machine_eval_codes (Block c1 :: c2) fuel s)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_machine_eval_codes_block_to_append (c1 c2 : codes) (fuel:nat) (s:machine_state) :
Lemma
(ensures (machine_eval_codes (c1 `L.append` c2) fuel s == machine_eval_codes (Block c1 :: c2) fuel s)) =
match c1 with
| [] -> ()
| x :: xs ->
match machine_eval_code x fuel s with
| None -> ()
... | val lemma_machine_eval_codes_block_to_append (c1 c2: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(machine_eval_codes (c1 `L.append` c2) fuel s == machine_eval_codes (Block c1 :: c2) fuel s))
let rec lemma_machine_eval_codes_block_to_append (c1 c2: codes) (fuel: nat) (s: machine_state)
: Lem... | false | null | true | match c1 with
| [] -> ()
| x :: xs ->
match machine_eval_code x fuel s with
| None -> ()
| Some s1 -> lemma_machine_eval_codes_block_to_append xs c2 fuel s1 | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.X64.Machine_Semantics_s.machine_eval_code",
"Vale.Transformers.InstructionReorder.lemma_machine_eval_cod... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 1,
"max_fuel": 3,
"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_el... | null | val lemma_machine_eval_codes_block_to_append (c1 c2: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures
(machine_eval_codes (c1 `L.append` c2) fuel s == machine_eval_codes (Block c1 :: c2) fuel s)) | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_machine_eval_codes_block_to_append | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c1: Vale.X64.Machine_Semantics_s.codes ->
c2: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(ensures
Vale.X64.Machine_Semantics_s.machine_eval_codes (c1 @ c2) fuel s ==
Vale.X64.Machine_Semantics_s.mach... | {
"end_col": 60,
"end_line": 1932,
"start_col": 2,
"start_line": 1926
} |
FStar.Pervasives.Lemma | val lemma_bubble_to_top (cs: codes) (i: nat{i < L.length cs}) (fuel: nat) (s s': machine_state)
: Lemma
(requires
((s'.ms_ok) /\ (Some s' == machine_eval_codes cs fuel s) /\ (Ok? (bubble_to_top cs i))))
(ensures
(let x = L.index cs i in
let Ok xs = bubble_to_top cs i in
... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let rec lemma_bubble_to_top (cs : codes) (i:nat{i < L.length cs}) (fuel:nat) (s s' : machine_state) :
Lemma
(requires (
(s'.ms_ok) /\
(Some s' == machine_eval_codes cs fuel s) /\
(Ok? (bubble_to_top cs i))))
(ensures (
let x = L.index cs i in
let Ok xs = bubble_to_top c... | val lemma_bubble_to_top (cs: codes) (i: nat{i < L.length cs}) (fuel: nat) (s s': machine_state)
: Lemma
(requires
((s'.ms_ok) /\ (Some s' == machine_eval_codes cs fuel s) /\ (Ok? (bubble_to_top cs i))))
(ensures
(let x = L.index cs i in
let Ok xs = bubble_to_top cs i in
... | false | null | true | match cs with
| [_] -> ()
| h :: t ->
let x = L.index cs i in
let Ok xs = bubble_to_top cs i in
if i = 0
then ()
else
(let Some s_h = machine_eval_code h fuel s in
lemma_bubble_to_top (L.tl cs) (i - 1) fuel s_h s';
let Some s_h_x = machine_eval_code x fuel s_h in
let Some s_hx = machine_... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.list",
"FStar.List.Tot.Base.split3",
"Prims.l_a... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 1,
"max_fuel": 3,
"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_el... | null | val lemma_bubble_to_top (cs: codes) (i: nat{i < L.length cs}) (fuel: nat) (s s': machine_state)
: Lemma
(requires
((s'.ms_ok) /\ (Some s' == machine_eval_codes cs fuel s) /\ (Ok? (bubble_to_top cs i))))
(ensures
(let x = L.index cs i in
let Ok xs = bubble_to_top cs i in
... | [
"recursion"
] | Vale.Transformers.InstructionReorder.lemma_bubble_to_top | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
cs: Vale.X64.Machine_Semantics_s.codes ->
i: Prims.nat{i < FStar.List.Tot.Base.length cs} ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
s': Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
Mkmachine_state?.ms_ok s' /\
FS... | {
"end_col": 5,
"end_line": 1919,
"start_col": 2,
"start_line": 1903
} |
FStar.Pervasives.Lemma | val lemma_machine_eval_ins_st_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (run (machine_eval_ins_st i) s1) (run (machine_eval_ins_st i) s2))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.BoundedInstructionEffects",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
... | false | let lemma_machine_eval_ins_st_equiv_states (i : ins) (s1 s2 : machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
equiv_states
(run (machine_eval_ins_st i) s1)
(run (machine_eval_ins_st i) s2))) =
let s1_orig, s2_orig = s1, s2 in
let s1_final = run (machine_eval_i... | val lemma_machine_eval_ins_st_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (run (machine_eval_ins_st i) s1) (run (machine_eval_ins_st i) s2)))
let lemma_machine_eval_ins_st_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_... | false | null | true | let s1_orig, s2_orig = s1, s2 in
let s1_final = run (machine_eval_ins_st i) s1 in
let s2_final = run (machine_eval_ins_st i) s2 in
match i with
| Instr it oprs ann -> lemma_eval_instr_equiv_states it oprs ann s1 s2
| Push _ _ -> assert_spinoff (equiv_states_ext s1_final s2_final)
| Pop dst t ->
let stack_op = OStack ... | {
"checked_file": "Vale.Transformers.InstructionReorder.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes... | [
"lemma"
] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Mach... | [] | (**
This module defines a transformer that performs safe instruction
reordering.
Example:
The following set of instructions can be reordered in any order
without any observable change in behavior:
mov rax, 10
mov rbx, 3
Usage:
Actual vale-tool or user-facing code should pr... | false | false | Vale.Transformers.InstructionReorder.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 0,
"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_el... | null | val lemma_machine_eval_ins_st_equiv_states (i: ins) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures (equiv_states (run (machine_eval_ins_st i) s1) (run (machine_eval_ins_st i) s2))) | [] | Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_st_equiv_states | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Machine_Semantics_s.ins ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Vale.Transformers.InstructionReorder.equiv_states s1 s2)
(ensures
Vale.Transformers.InstructionReorder.equiv_states (Va... | {
"end_col": 55,
"end_line": 404,
"start_col": 46,
"start_line": 371
} |
Prims.Tot | val to_fun (m: t) : regs_fun | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let to_fun (m:t) : regs_fun =
FStar.FunctionalExtensionality.on_dom reg (fun (r:reg) -> sel r m) | val to_fun (m: t) : regs_fun
let to_fun (m: t) : regs_fun = | false | null | false | FStar.FunctionalExtensionality.on_dom reg (fun (r: reg) -> sel r m) | {
"checked_file": "Vale.X64.Regs.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FSt... | [
"total"
] | [
"Vale.X64.Regs.t",
"FStar.FunctionalExtensionality.on_dom",
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Regs.sel",
"Vale.X64.Regs.regs_fun"
] | [] | module Vale.X64.Regs
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
type regs_fun = FStar.FunctionalExtensionality.restricted_t reg t_reg
type regs_def = map16 nat64 & map16 quad32
[@"opaque_to_smt"]
type t = regs_def
[@va_qa... | false | true | Vale.X64.Regs.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_el... | null | val to_fun (m: t) : regs_fun | [] | Vale.X64.Regs.to_fun | {
"file_name": "vale/code/arch/x64/Vale.X64.Regs.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.X64.Regs.t -> Vale.X64.Regs.regs_fun | {
"end_col": 68,
"end_line": 53,
"start_col": 2,
"start_line": 53
} |
Prims.Tot | val eta_sel (r: reg) (m: t) : v: (t_reg r){v == sel r m} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let eta_sel (r:reg) (m:t) : v:(t_reg r){v == sel r m} =
sel r m | val eta_sel (r: reg) (m: t) : v: (t_reg r){v == sel r m}
let eta_sel (r: reg) (m: t) : v: (t_reg r){v == sel r m} = | false | null | false | sel r m | {
"checked_file": "Vale.X64.Regs.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FSt... | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Regs.t",
"Vale.X64.Regs.sel",
"Vale.X64.Machine_s.t_reg",
"Prims.eq2"
] | [] | module Vale.X64.Regs
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
type regs_fun = FStar.FunctionalExtensionality.restricted_t reg t_reg
type regs_def = map16 nat64 & map16 quad32
[@"opaque_to_smt"]
type t = regs_def
[@va_qa... | false | false | Vale.X64.Regs.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_el... | null | val eta_sel (r: reg) (m: t) : v: (t_reg r){v == sel r m} | [] | Vale.X64.Regs.eta_sel | {
"file_name": "vale/code/arch/x64/Vale.X64.Regs.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg -> m: Vale.X64.Regs.t
-> v: Vale.X64.Machine_s.t_reg r {v == Vale.X64.Regs.sel r m} | {
"end_col": 9,
"end_line": 34,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | val sel (r: reg) (m: t) : t_reg r | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let sel (r:reg) (m:t) : t_reg r =
match m with (m0, m1) ->
match r with Reg rf i ->
match rf with
| 0 -> sel16 m0 i
| 1 -> sel16 m1 i | val sel (r: reg) (m: t) : t_reg r
let sel (r: reg) (m: t) : t_reg r = | false | null | false | match m with
| m0, m1 ->
match r with
| Reg rf i ->
match rf with
| 0 -> sel16 m0 i
| 1 -> sel16 m1 i | {
"checked_file": "Vale.X64.Regs.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FSt... | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Regs.t",
"Vale.Lib.Map16.map16",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_file_id",
"Vale.X64.Machine_s.reg_id",
"Vale.Lib.Map16.sel16",
"Vale.X64.Machine_s.t_reg"
] | [] | module Vale.X64.Regs
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
type regs_fun = FStar.FunctionalExtensionality.restricted_t reg t_reg
type regs_def = map16 nat64 & map16 quad32
[@"opaque_to_smt"]
type t = regs_def
[@va_qa... | false | false | Vale.X64.Regs.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_el... | null | val sel (r: reg) (m: t) : t_reg r | [] | Vale.X64.Regs.sel | {
"file_name": "vale/code/arch/x64/Vale.X64.Regs.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg -> m: Vale.X64.Regs.t -> Vale.X64.Machine_s.t_reg r | {
"end_col": 19,
"end_line": 21,
"start_col": 2,
"start_line": 17
} |
Prims.Tot | val upd (r: reg) (v: t_reg r) (m: t) : t | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let upd (r:reg) (v:t_reg r) (m:t) : t =
match m with (m0, m1) ->
match r with Reg rf i ->
match rf with
| 0 -> (upd16 m0 i v, m1)
| 1 -> (m0, upd16 m1 i v) | val upd (r: reg) (v: t_reg r) (m: t) : t
let upd (r: reg) (v: t_reg r) (m: t) : t = | false | null | false | match m with
| m0, m1 ->
match r with
| Reg rf i ->
match rf with
| 0 -> (upd16 m0 i v, m1)
| 1 -> (m0, upd16 m1 i v) | {
"checked_file": "Vale.X64.Regs.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FSt... | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Regs.t",
"Vale.Lib.Map16.map16",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_file_id",
"Vale.X64.Machine_s.reg_id",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Lib.Map16.upd16"
] | [] | module Vale.X64.Regs
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
type regs_fun = FStar.FunctionalExtensionality.restricted_t reg t_reg
type regs_def = map16 nat64 & map16 quad32
[@"opaque_to_smt"]
type t = regs_def
[@va_qa... | false | false | Vale.X64.Regs.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_el... | null | val upd (r: reg) (v: t_reg r) (m: t) : t | [] | Vale.X64.Regs.upd | {
"file_name": "vale/code/arch/x64/Vale.X64.Regs.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg -> v: Vale.X64.Machine_s.t_reg r -> m: Vale.X64.Regs.t -> Vale.X64.Regs.t | {
"end_col": 27,
"end_line": 29,
"start_col": 2,
"start_line": 25
} |
Prims.Tot | val eta (m: t) : t | [
{
"abbrev": false,
"full_module": "Vale.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_mo... | false | let eta (m:t) : t =
let m0_3 = ((eta_sel (Reg 0 0) m, eta_sel (Reg 0 1) m), (eta_sel (Reg 0 2) m, eta_sel (Reg 0 3) m)) in
let m4_7 = ((eta_sel (Reg 0 4) m, eta_sel (Reg 0 5) m), (eta_sel (Reg 0 6) m, eta_sel (Reg 0 7) m)) in
let m8_11 = ((eta_sel (Reg 0 8) m, eta_sel (Reg 0 9) m), (eta_sel (Reg 0 10) m, eta_sel ... | val eta (m: t) : t
let eta (m: t) : t = | false | null | false | let m0_3 =
((eta_sel (Reg 0 0) m, eta_sel (Reg 0 1) m), (eta_sel (Reg 0 2) m, eta_sel (Reg 0 3) m))
in
let m4_7 =
((eta_sel (Reg 0 4) m, eta_sel (Reg 0 5) m), (eta_sel (Reg 0 6) m, eta_sel (Reg 0 7) m))
in
let m8_11 =
((eta_sel (Reg 0 8) m, eta_sel (Reg 0 9) m), (eta_sel (Reg 0 10) m, eta_sel (Reg 0 11) m))
in
le... | {
"checked_file": "Vale.X64.Regs.fsti.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FSt... | [
"total"
] | [
"Vale.X64.Regs.t",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Lib.Map16.map16",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.quad32",
"FStar.Pervasives.Native.tuple2",
"Vale.Lib.Map16.map8",
"Vale.Def.Types_s.quad32",
"Vale.Lib.Map16.map4",
"Vale.Lib.Map16.map2",
"Vale.X64.Regs.eta_sel",
"Va... | [] | module Vale.X64.Regs
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.X64.Machine_s
open Vale.Lib.Map16
type regs_fun = FStar.FunctionalExtensionality.restricted_t reg t_reg
type regs_def = map16 nat64 & map16 quad32
[@"opaque_to_smt"]
type t = regs_def
[@va_qa... | false | true | Vale.X64.Regs.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_el... | null | val eta (m: t) : t | [] | Vale.X64.Regs.eta | {
"file_name": "vale/code/arch/x64/Vale.X64.Regs.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.X64.Regs.t -> Vale.X64.Regs.t | {
"end_col": 10,
"end_line": 50,
"start_col": 19,
"start_line": 39
} |
Prims.Tot | val shift_gf128_key_1 (h: poly) : poly | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let shift_gf128_key_1 (h:poly) : poly =
shift_key_1 128 gf128_modulus_low_terms h | val shift_gf128_key_1 (h: poly) : poly
let shift_gf128_key_1 (h: poly) : poly = | false | null | false | shift_key_1 128 gf128_modulus_low_terms h | {
"checked_file": "Vale.AES.OptPublic_BE.fst.checked",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF1... | [
"total"
] | [
"Vale.Math.Poly2_s.poly",
"Vale.AES.GF128.shift_key_1",
"Vale.AES.GF128_s.gf128_modulus_low_terms"
] | [] | module Vale.AES.OptPublic_BE
open FStar.Mul
open FStar.Seq
open Vale.Def.Types_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.Def.Words_s | false | true | Vale.AES.OptPublic_BE.fst | {
"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_el... | null | val shift_gf128_key_1 (h: poly) : poly | [] | Vale.AES.OptPublic_BE.shift_gf128_key_1 | {
"file_name": "vale/code/crypto/aes/Vale.AES.OptPublic_BE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: Vale.Math.Poly2_s.poly -> Vale.Math.Poly2_s.poly | {
"end_col": 43,
"end_line": 13,
"start_col": 2,
"start_line": 13
} |
Prims.Tot | val gf128_power (h: poly) (n: nat) : poly | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let gf128_power (h:poly) (n:nat) : poly = shift_gf128_key_1 (g_power h n) | val gf128_power (h: poly) (n: nat) : poly
let gf128_power (h: poly) (n: nat) : poly = | false | null | false | shift_gf128_key_1 (g_power h n) | {
"checked_file": "Vale.AES.OptPublic_BE.fst.checked",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF1... | [
"total"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Vale.AES.OptPublic_BE.shift_gf128_key_1",
"Vale.AES.OptPublic_BE.g_power"
] | [] | module Vale.AES.OptPublic_BE
open FStar.Mul
open FStar.Seq
open Vale.Def.Types_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.Def.Words_s
let shift_gf128_key_1 (h:poly) : poly =
shift_key_1 128 gf128_modulus_low_terms h
let rec g_power (a:poly) (n:nat) : po... | false | true | Vale.AES.OptPublic_BE.fst | {
"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_el... | null | val gf128_power (h: poly) (n: nat) : poly | [] | Vale.AES.OptPublic_BE.gf128_power | {
"file_name": "vale/code/crypto/aes/Vale.AES.OptPublic_BE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: Vale.Math.Poly2_s.poly -> n: Prims.nat -> Vale.Math.Poly2_s.poly | {
"end_col": 73,
"end_line": 20,
"start_col": 42,
"start_line": 20
} |
Prims.Tot | val g_power (a: poly) (n: nat) : poly | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let rec g_power (a:poly) (n:nat) : poly =
if n = 0 then zero else // arbitrary value for n = 0
if n = 1 then a else
a *~ g_power a (n - 1) | val g_power (a: poly) (n: nat) : poly
let rec g_power (a: poly) (n: nat) : poly = | false | null | false | if n = 0 then zero else if n = 1 then a else a *~ g_power a (n - 1) | {
"checked_file": "Vale.AES.OptPublic_BE.fst.checked",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF1... | [
"total"
] | [
"Vale.Math.Poly2_s.poly",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Vale.Math.Poly2_s.zero",
"Prims.bool",
"Vale.AES.GF128.op_Star_Tilde",
"Vale.AES.OptPublic_BE.g_power",
"Prims.op_Subtraction"
] | [] | module Vale.AES.OptPublic_BE
open FStar.Mul
open FStar.Seq
open Vale.Def.Types_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.Def.Words_s
let shift_gf128_key_1 (h:poly) : poly =
shift_key_1 128 gf128_modulus_low_terms h | false | true | Vale.AES.OptPublic_BE.fst | {
"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_el... | null | val g_power (a: poly) (n: nat) : poly | [
"recursion"
] | Vale.AES.OptPublic_BE.g_power | {
"file_name": "vale/code/crypto/aes/Vale.AES.OptPublic_BE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2_s.poly -> n: Prims.nat -> Vale.Math.Poly2_s.poly | {
"end_col": 24,
"end_line": 18,
"start_col": 2,
"start_line": 16
} |
Prims.Tot | val hkeys_reqs_pub (hkeys:FStar.Seq.seq quad32) (h_BE:quad32) : Vale.Def.Prop_s.prop0 | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let hkeys_reqs_pub (hkeys:seq quad32) (h_BE:quad32) : Vale.Def.Prop_s.prop0
=
let h = of_quad32 h_BE in
length hkeys >= 3 /\
of_quad32 (index hkeys 0) == gf128_power h 1 /\
of_quad32 (index hkeys 1) == gf128_power h 2 /\
index hkeys 2 == h_BE | val hkeys_reqs_pub (hkeys:FStar.Seq.seq quad32) (h_BE:quad32) : Vale.Def.Prop_s.prop0
let hkeys_reqs_pub (hkeys: seq quad32) (h_BE: quad32) : Vale.Def.Prop_s.prop0 = | false | null | false | let h = of_quad32 h_BE in
length hkeys >= 3 /\ of_quad32 (index hkeys 0) == gf128_power h 1 /\
of_quad32 (index hkeys 1) == gf128_power h 2 /\ index hkeys 2 == h_BE | {
"checked_file": "Vale.AES.OptPublic_BE.fst.checked",
"dependencies": [
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF1... | [
"total"
] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"Prims.eq2",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"FStar.Seq.Base.index",
"Vale.AES.OptPublic_BE.gf128_power",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.AES.OptPublic_BE
open FStar.Mul
open FStar.Seq
open Vale.Def.Types_s
open Vale.Math.Poly2_s
open Vale.Math.Poly2.Bits_s
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.Def.Words_s
let shift_gf128_key_1 (h:poly) : poly =
shift_key_1 128 gf128_modulus_low_terms h
let rec g_power (a:poly) (n:nat) : po... | false | true | Vale.AES.OptPublic_BE.fst | {
"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_el... | null | val hkeys_reqs_pub (hkeys:FStar.Seq.seq quad32) (h_BE:quad32) : Vale.Def.Prop_s.prop0 | [] | Vale.AES.OptPublic_BE.hkeys_reqs_pub | {
"file_name": "vale/code/crypto/aes/Vale.AES.OptPublic_BE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | hkeys: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> h_BE: Vale.Def.Types_s.quad32
-> Vale.Def.Prop_s.prop0 | {
"end_col": 23,
"end_line": 28,
"start_col": 3,
"start_line": 23
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let perm (#t: Type) (b: B.buffer t) = (x: perm0 t { perm_prop x b }) | let perm (#t: Type) (b: B.buffer t) = | false | null | false | (x: perm0 t {perm_prop x b}) | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"total"
] | [
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm0",
"EverParse3d.Readable.perm_prop"
] | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val perm : b: LowStar.Buffer.buffer t -> Type0 | [] | EverParse3d.Readable.perm | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | b: LowStar.Buffer.buffer t -> Type0 | {
"end_col": 68,
"end_line": 16,
"start_col": 38,
"start_line": 16
} | |
FStar.Pervasives.Lemma | val readable_frame
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from: U32.t)
(to: U32.t{U32.v from <= U32.v to /\ U32.v to <= B.length b})
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(readable h p from to /\ B.modifies l h h' /\ B.loc_disjoint (loc_pe... | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let readable_frame
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(from: U32.t)
(to: U32.t { U32.v from <= U32.v to /\ U32.v to <= B.length b })
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
readable h p from to /\
B.modifies l h h' /\
B.loc_disjoint (loc_perm p) l /\
B.live h' b // becau... | val readable_frame
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from: U32.t)
(to: U32.t{U32.v from <= U32.v to /\ U32.v to <= B.length b})
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(readable h p from to /\ B.modifies l h h' /\ B.loc_disjoint (loc_pe... | false | null | true | valid_perm_frame h p l h';
preserved_split p 0ul from (B.len b) h h';
preserved_split p from to (B.len b) h h';
readable_frame0 h p from to h' | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.loc",
"EverParse3d... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val readable_frame
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from: U32.t)
(to: U32.t{U32.v from <= U32.v to /\ U32.v to <= B.length b})
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(readable h p from to /\ B.modifies l h h' /\ B.loc_disjoint (loc_pe... | [] | EverParse3d.Readable.readable_frame | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
from: FStar.UInt32.t ->
to:
FStar.UInt32.t
{ FStar.UInt32.v from <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.length b } ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monoto... | {
"end_col": 32,
"end_line": 204,
"start_col": 2,
"start_line": 201
} |
FStar.Pervasives.Lemma | val unreadable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from to))
(ensures (unreadable h p from mid /\ unreadable h p m... | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let unreadable_split'
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(from: U32.t)
(mid: U32.t)
(to: U32.t { U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b })
: Lemma
(requires (unreadable h p from to))
(ensures (unreadable h p from mid /\ unreadable h p mid to))
= unreadable... | val unreadable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from to))
(ensures (unreadable h p from mid /\ unreadable h p m... | false | null | true | unreadable_split h p from mid to | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"EverParse3d.Readable.unreadable_split",
"Pr... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val unreadable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from to))
(ensures (unreadable h p from mid /\ unreadable h p m... | [] | EverParse3d.Readable.unreadable_split' | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
from: FStar.UInt32.t ->
mid: FStar.UInt32.t ->
to:
FStar.UInt32.t
{ FStar.UInt32.v from <= FStar.UInt32.v mid /\ FStar.UInt32.v mid <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.le... | {
"end_col": 34,
"end_line": 249,
"start_col": 2,
"start_line": 249
} |
FStar.Pervasives.Lemma | val readable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from to))
(ensures (readable h p from mid /\ readable h p mid to)) | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let readable_split'
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(from: U32.t)
(mid: U32.t)
(to: U32.t { U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b })
: Lemma
(requires (readable h p from to))
(ensures (readable h p from mid /\ readable h p mid to))
= readable_split h p... | val readable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from to))
(ensures (readable h p from mid /\ readable h p mid to))
... | false | null | true | readable_split h p from mid to | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"EverParse3d.Readable.readable_split",
"Prim... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val readable_split'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from to))
(ensures (readable h p from mid /\ readable h p mid to)) | [] | EverParse3d.Readable.readable_split' | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
from: FStar.UInt32.t ->
mid: FStar.UInt32.t ->
to:
FStar.UInt32.t
{ FStar.UInt32.v from <= FStar.UInt32.v mid /\ FStar.UInt32.v mid <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.le... | {
"end_col": 32,
"end_line": 148,
"start_col": 2,
"start_line": 148
} |
FStar.Pervasives.Lemma | val readable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from mid /\ readable h p mid to))
(ensures (readable h p from to)) | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let readable_merge'
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(from: U32.t)
(mid: U32.t)
(to: U32.t { U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b })
: Lemma
(requires (
readable h p from mid /\
readable h p mid to
))
(ensures (readable h p from to))
= readab... | val readable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from mid /\ readable h p mid to))
(ensures (readable h p from to))
... | false | null | true | readable_split h p from mid to | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"EverParse3d.Readable.readable_split",
"Prim... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val readable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (readable h p from mid /\ readable h p mid to))
(ensures (readable h p from to)) | [] | EverParse3d.Readable.readable_merge' | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
from: FStar.UInt32.t ->
mid: FStar.UInt32.t ->
to:
FStar.UInt32.t
{ FStar.UInt32.v from <= FStar.UInt32.v mid /\ FStar.UInt32.v mid <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.le... | {
"end_col": 32,
"end_line": 162,
"start_col": 2,
"start_line": 162
} |
FStar.Pervasives.Lemma | val valid_perm_frame_pat (h: HS.mem) (#t: _) (#b: B.buffer t) (p: perm b) (l: B.loc) (h': HS.mem)
: Lemma
(requires
(valid_perm h p /\ B.modifies l h h' /\ B.loc_disjoint (loc_perm p) l /\ B.live h' b))
(ensures (valid_perm h' p /\ preserved p 0ul (B.len b) h h'))
[
SMTPatOr
... | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let valid_perm_frame_pat
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid_perm h p /\
B.modifies l h h' /\
B.loc_disjoint (loc_perm p) l /\
B.live h' b // because nothing prevents b from being deallocated
))
(ensures (
valid_perm h' p ... | val valid_perm_frame_pat (h: HS.mem) (#t: _) (#b: B.buffer t) (p: perm b) (l: B.loc) (h': HS.mem)
: Lemma
(requires
(valid_perm h p /\ B.modifies l h h' /\ B.loc_disjoint (loc_perm p) l /\ B.live h' b))
(ensures (valid_perm h' p /\ preserved p 0ul (B.len b) h h'))
[
SMTPatOr
... | false | null | true | valid_perm_frame h p l h' | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"LowStar.Monotonic.Buffer.loc",
"EverParse3d.Readable.valid_perm_frame",
"Prims.unit",
"Prims.l_and",
"EverParse3d.Readable.valid_perm",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoi... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val valid_perm_frame_pat (h: HS.mem) (#t: _) (#b: B.buffer t) (p: perm b) (l: B.loc) (h': HS.mem)
: Lemma
(requires
(valid_perm h p /\ B.modifies l h h' /\ B.loc_disjoint (loc_perm p) l /\ B.live h' b))
(ensures (valid_perm h' p /\ preserved p 0ul (B.len b) h h'))
[
SMTPatOr
... | [] | EverParse3d.Readable.valid_perm_frame_pat | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
EverParse3d.Readable.valid_perm h p /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.B... | {
"end_col": 27,
"end_line": 80,
"start_col": 2,
"start_line": 80
} |
FStar.Pervasives.Lemma | val unreadable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from mid /\ unreadable h p mid to))
(ensures (unreadable h p fr... | [
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LPL"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_mo... | false | let unreadable_merge'
(h: HS.mem)
(#t: _) (#b: B.buffer t) (p: perm b)
(from: U32.t)
(mid: U32.t)
(to: U32.t { U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b })
: Lemma
(requires (
unreadable h p from mid /\
unreadable h p mid to
))
(ensures (unreadable h p from to))
... | val unreadable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from mid /\ unreadable h p mid to))
(ensures (unreadable h p fr... | false | null | true | unreadable_split h p from mid to | {
"checked_file": "EverParse3d.Readable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Buffer.buffer",
"EverParse3d.Readable.perm",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"EverParse3d.Readable.unreadable_split",
"Pr... | [] | module EverParse3d.Readable
module B = LowStar.Buffer
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
module LPL = LowParse.Low.Base
// not erasable because Low* buffers of erased elements are not erasable
inline_for_extraction noextract
val perm0 (t: Type) : Tot Type0
val per... | false | false | EverParse3d.Readable.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"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_el... | null | val unreadable_merge'
(h: HS.mem)
(#t: _)
(#b: B.buffer t)
(p: perm b)
(from mid: U32.t)
(to: U32.t{U32.v from <= U32.v mid /\ U32.v mid <= U32.v to /\ U32.v to <= B.length b})
: Lemma (requires (unreadable h p from mid /\ unreadable h p mid to))
(ensures (unreadable h p fr... | [] | EverParse3d.Readable.unreadable_merge' | {
"file_name": "src/3d/prelude/buffer/EverParse3d.Readable.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
p: EverParse3d.Readable.perm b ->
from: FStar.UInt32.t ->
mid: FStar.UInt32.t ->
to:
FStar.UInt32.t
{ FStar.UInt32.v from <= FStar.UInt32.v mid /\ FStar.UInt32.v mid <= FStar.UInt32.v to /\
FStar.UInt32.v to <= LowStar.Monotonic.Buffer.le... | {
"end_col": 34,
"end_line": 263,
"start_col": 2,
"start_line": 263
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.