file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.run2 | val run2 (f1 f2: st unit) (s: machine_state) : machine_state | val run2 (f1 f2: st unit) (s: machine_state) : machine_state | let run2 (f1 f2:st unit) (s:machine_state) : machine_state =
let open Vale.X64.Machine_Semantics_s in
run (f1;* f2;* return ()) s | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 558,
"start_col": 0,
"start_line": 556
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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 | Prims.Tot | [
"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"
] | [] | false | false | false | true | false | let run2 (f1 f2: st unit) (s: machine_state) : machine_state =
| let open Vale.X64.Machine_Semantics_s in
run (let* _ = f1 in
let* _ = f2 in
return ())
s | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instr_write_outputs_equiv_states | 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
... | 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
... | 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)))
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 323,
"start_col": 0,
"start_line": 289
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
... | [
"recursion"
] | false | false | true | false | 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 s_orig2 s2: machine_state)
: Lemma (requires ((equiv_states s_orig1 s_orig2) /\ (equiv_states s1 s2)))
(ensures
... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.equiv_option_states | 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 | 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)) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 186,
"start_col": 0,
"start_line": 184
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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 | Prims.Tot | [
"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... | [] | false | false | false | true | true | 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)) | false | |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_eval_ins_equiv_states | 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))) | 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_states
(machine_eval_ins i s1)
(machine_eval_ins i s2))) =
lemma_machine_eval_ins_st_equiv_states i s1 s2 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 414,
"start_col": 0,
"start_line": 407
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | true | false | true | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instr_write_output_implicit_equiv_states | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 269,
"start_col": 0,
"start_line": 255
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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.... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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_implicit i v s_orig... | 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) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instr_write_output_explicit_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... | 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... | 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
(... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 285,
"start_col": 0,
"start_line": 271
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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 (instr_wri... | 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) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.wrap_ss | val wrap_ss (f: (machine_state -> machine_state)) : st unit | val wrap_ss (f: (machine_state -> machine_state)) : st unit | 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) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 1030,
"start_col": 0,
"start_line": 1027
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | f: (_: Vale.X64.Machine_Semantics_s.machine_state -> Vale.X64.Machine_Semantics_s.machine_state)
-> Vale.X64.Machine_Semantics_s.st Prims.unit | Prims.Tot | [
"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"
] | [] | false | false | false | true | 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) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_unchanged_except_append_symmetric | 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)) | 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
(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))) ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 607,
"start_col": 0,
"start_line": 596
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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.... | [] | false | false | true | false | 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))) \/
(!!(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... | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.siggen_vector | val siggen_vector : Type0 | let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8 | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 78,
"start_col": 0,
"start_line": 78
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple7",
"Hacl.Test.ECDSA.vec8"
] | [] | false | false | false | true | true | let siggen_vector =
| vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8 | false | |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instr_apply_eval_args_equiv_states | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 218,
"start_col": 0,
"start_line": 197
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 op... | 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_... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_append | 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)))) | 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_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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 584,
"start_col": 0,
"start_line": 575
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 -> lemma_disjoint_location_from_locations_append a xs as2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_eval_instr_equiv_states | 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))) | 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_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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 357,
"start_col": 0,
"start_line": 325
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
"... | [] | false | false | true | false | 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 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.value_of_const_loc | 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 | 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 =
let x :: xs = lv in
if dfst x = l then dsnd x else value_of_const_loc xs l | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 656,
"start_col": 0,
"start_line": 652
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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 | Prims.Tot | [
"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... | [
"recursion"
] | false | false | false | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem | 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))) | 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
(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
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 622,
"start_col": 0,
"start_line": 610
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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 ... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 lemma_disjoint_location_from_locations_mem xs a2 a | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_unchanged_except_transitive | 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)) | 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) :
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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 594,
"start_col": 0,
"start_line": 586
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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` 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) | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.sigver_vector | val sigver_vector : Type0 | let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 76,
"start_col": 0,
"start_line": 76
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple6",
"Hacl.Test.ECDSA.vec8",
"Prims.bool"
] | [] | false | false | false | true | true | let sigver_vector =
| vec8 & vec8 & vec8 & vec8 & vec8 & bool | false | |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_disjoint_implies_unchanged_at | 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)) | 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: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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 573,
"start_col": 0,
"start_line": 565
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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_implies_unchanged_at xs changes s1 s2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_disjoint_location_from_locations_mem1 | 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))) | 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 (!!(disjoint_location_from_locations a as0))) =
match as0 with
| [] -> ()
| x :: xs -> lemma_disjoint_location_from_locations_mem1 a xs | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 650,
"start_col": 0,
"start_line": 644
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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)) | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_write_same_constants_append | 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)))) | 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) :
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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 666,
"start_col": 0,
"start_line": 658
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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_constants_append xs c1' c2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_mem_not_disjoint | 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)))) | 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_locations as1 as2)))) =
match as1, as2 with
| [_], [_] -> ()
| [_], y :: ys ->
if a = y then () else (
lemma_mem_not_disjoint a as1 ys
)
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 836,
"start_col": 0,
"start_line": 816
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
... | [
"recursion"
] | false | false | true | false | 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)
| 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_unchanged_at_mem | 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))) | 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
(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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 708,
"start_col": 0,
"start_line": 697
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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"... | [
"recursion"
] | false | false | true | false | 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 lemma_unchanged_at_mem xs a s1 s2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_constant_on_execution_mem | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 641,
"start_col": 0,
"start_line": 626
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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
... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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... | match locv with
| [_] -> ()
| x :: xs -> if x = (| l, v |) then () else (lemma_constant_on_execution_mem xs f s l v) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_equiv_states_when_except_none | 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 })))) | 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_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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 813,
"start_col": 0,
"start_line": 805
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | true | false | true | false | 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);
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 [] | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_unchanged_at_and_except | 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))) | 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 (
(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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 803,
"start_col": 0,
"start_line": 793
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 s2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instr_apply_eval_inouts_equiv_states | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 82,
"end_line": 250,
"start_col": 0,
"start_line": 221
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
"... | [
"recursion"
] | false | false | true | false | 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... | 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
| ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.wrap_sos | val wrap_sos (f: (machine_state -> option machine_state)) : st unit | val wrap_sos (f: (machine_state -> option machine_state)) : st unit | 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'
) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 1037,
"start_col": 0,
"start_line": 1032
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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 | Prims.Tot | [
"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__... | [] | false | false | false | true | 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') | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_write_same_constants_mem_both | 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... | 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... | 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 ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 685,
"start_col": 0,
"start_line": 668
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
... | [
"recursion"
] | false | false | true | false | 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 l = valu... | 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) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_unchanged_at_combine | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 783,
"start_col": 0,
"start_line": 711
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
"... | [] | false | false | true | false | 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 (location... | 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
... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_feq_bounded_effects | 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)) | 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.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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1066,
"start_col": 0,
"start_line": 1039
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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.__... | [] | false | false | true | false | 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 (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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_st_exchange | 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))) | 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_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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 1102,
"start_col": 0,
"start_line": 1092
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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",
"... | [] | true | false | true | false | 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_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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.code_exchange_allowed | val code_exchange_allowed (c1 c2: safely_bounded_code) : pbool | val code_exchange_allowed (c1 c2: safely_bounded_code) : pbool | 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)) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 101,
"end_line": 1451,
"start_col": 0,
"start_line": 1449
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
c1: Vale.Transformers.InstructionReorder.safely_bounded_code ->
c2: Vale.Transformers.InstructionReorder.safely_bounded_code
-> Vale.Def.PossiblyMonad.pbool | Prims.Tot | [
"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... | [] | false | false | false | true | 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)) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_both_not_ok | 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)) | 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) (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 (... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 864,
"start_col": 0,
"start_line": 850
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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
(... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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 (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)) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_value_of_const_loc_mem | 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)) | 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) (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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 694,
"start_col": 0,
"start_line": 687
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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_... | FStar.Pervasives.Lemma | [
"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",
... | [
"recursion"
] | false | false | true | false | 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_of_const_loc_mem xs l v | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_many | val test_many : label: C.String.t ->
f: (_: a -> FStar.HyperStack.ST.Stack Prims.unit) ->
vec: Test.Lowstarize.lbuffer a
-> FStar.HyperStack.ST.STATE Prims.unit | let test_many #a (label:C.String.t)
(f:a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)) (vec: L.lbuffer a)
=
C.String.print label;
C.String.(print !$"\n");
let L.LB len vs = vec in
let f (i:UInt32.t{0 <= v i /\ v i < v len}): Stack unit
(requires fun h -> True)
(ensures fun h0 _ h1 -> True)
=
... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 479,
"start_col": 0,
"start_line": 464
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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... | false |
label: C.String.t ->
f: (_: a -> FStar.HyperStack.ST.Stack Prims.unit) ->
vec: Test.Lowstarize.lbuffer a
-> FStar.HyperStack.ST.STATE Prims.unit | FStar.HyperStack.ST.STATE | [] | [] | [
"C.String.t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Test.Lowstarize.lbuffer",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"C.Loops.f... | [] | false | true | false | false | false | let test_many
#a
(label: C.String.t)
(f: (a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)))
(vec: L.lbuffer a)
=
| C.String.print label;
(let open C.String in print !$"\n");
let L.LB len vs = vec in
let f (i: UInt32.t{0 <= v i /\ v i < v len})
: Stack unit (requires fun h -> True) (ensures fun h0 _ h1 -> True) =
let open LowStar.BufferOps in
B.recall vs;
(let open LowStar.Printf in printf "ECDSA Test %ul/%ul\n" (i +! 1ul)... | false | |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.compare_and_print | val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1) | val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1) | let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 95,
"start_col": 0,
"start_line": 85
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false |
b1: LowStar.Buffer.buffer FStar.UInt8.t ->
b2: LowStar.Buffer.buffer FStar.UInt8.t ->
len: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Lib.ByteBuffer.lbytes_eq",
"LowStar.Buffer.trivial_preorder",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let compare_and_print b1 b2 len =
| push_frame ();
(let open LowStar.Printf in printf "Expected: %xuy\n" len b1 done);
(let open LowStar.Printf in printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b
then let open LowStar.Printf in printf "PASS\n" done
else (let open LowStar.Printf in printf "FAIL\n" done);
pop_fram... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.safely_bounded_code_p | val safely_bounded_code_p (c: code) : bool | val safely_bounded_code_p (c: code) : bool | let rec safely_bounded_code_p (c:code) : bool =
match c with
| Ins i -> safely_bounded i
| Block l -> safely_bounded_codes_p l
| IfElse c t f -> false (* Temporarily disabled. TODO: Re-enable this. safely_bounded_code_p t && safely_bounded_code_p f *)
| While c b -> false (* Temporarily disabled. TODO: Re-ena... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 1080,
"start_col": 0,
"start_line": 1068
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> Prims.bool | Prims.Tot | [
"total"
] | [
"safely_bounded_code_p",
"safely_bounded_codes_p"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.Transformers.BoundedInstructionEffects.safely_bounded",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.InstructionReorder.saf... | [
"mutual recursion"
] | false | false | false | true | false | let rec safely_bounded_code_p (c: code) : bool =
| match c with
| Ins i -> safely_bounded i
| Block l -> safely_bounded_codes_p l
| IfElse c t f -> false
| While c b -> false | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instruction_exchange' | 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... | 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... | 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)... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 82,
"end_line": 1116,
"start_col": 0,
"start_line": 1104
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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) /\
... | FStar.Pervasives.Lemma | [
"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",
... | [] | true | false | true | false | 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)
i... | 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) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_instruction_exchange | 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 (... | 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 (... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 1134,
"start_col": 0,
"start_line": 1118
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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) /\
... | FStar.Pervasives.Lemma | [
"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... | [] | true | false | true | false | 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 (filt_state (... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_machine_eval_ins_bounded_effects | 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)))) | 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)))) =
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)) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 1090,
"start_col": 0,
"start_line": 1086
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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... | FStar.Pervasives.Lemma | [
"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... | [] | true | false | true | false | 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)) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_commute | 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))) | 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: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 ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1025,
"start_col": 0,
"start_line": 982
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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
(... | FStar.Pervasives.Lemma | [
"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_... | [] | false | false | true | false | 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 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_... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.safely_bounded_codes_p | val safely_bounded_codes_p (l: codes) : bool | val safely_bounded_codes_p (l: codes) : bool | let rec safely_bounded_code_p (c:code) : bool =
match c with
| Ins i -> safely_bounded i
| Block l -> safely_bounded_codes_p l
| IfElse c t f -> false (* Temporarily disabled. TODO: Re-enable this. safely_bounded_code_p t && safely_bounded_code_p f *)
| While c b -> false (* Temporarily disabled. TODO: Re-ena... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 1080,
"start_col": 0,
"start_line": 1068
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | l: Vale.X64.Machine_Semantics_s.codes -> Prims.bool | Prims.Tot | [
"total"
] | [
"safely_bounded_code_p",
"safely_bounded_codes_p"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Prims.op_AmpAmp",
"Vale.Transformers.InstructionReorder.safely_bounded_code_p",
"Vale.Transformers.InstructionReorder.safely_bounded_codes_p",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec safely_bounded_codes_p (l: codes) : bool =
| match l with
| [] -> true
| x :: xs -> safely_bounded_code_p x && safely_bounded_codes_p xs | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux3 | 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... | 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... | 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)) ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 1355,
"start_col": 0,
"start_line": 1330
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.eq_ins | val eq_ins (i1 i2: ins) : bool | val eq_ins (i1 i2: ins) : bool | let eq_ins (i1 i2:ins) : bool =
print_ins i1 gcc = print_ins i2 gcc | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 1695,
"start_col": 0,
"start_line": 1694
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | i1: Vale.X64.Machine_Semantics_s.ins -> i2: Vale.X64.Machine_Semantics_s.ins -> Prims.bool | Prims.Tot | [
"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"
] | [] | false | false | false | true | false | let eq_ins (i1 i2: ins) : bool =
| print_ins i1 gcc = print_ins i2 gcc | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_on_functional_extensionality | 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)) | 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
(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 ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 1238,
"start_col": 0,
"start_line": 1215
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.rw_set_of_code | val rw_set_of_code (c: safely_bounded_code) : rw_set | val rw_set_of_code (c: safely_bounded_code) : rw_set | let rec rw_set_of_code (c:safely_bounded_code) : rw_set =
match c with
| Ins i -> rw_set_of_ins i
| Block l -> rw_set_of_codes l
| IfElse c t f ->
add_r_to_rw_set
(locations_of_ocmp c)
(rw_set_in_parallel
(rw_set_of_code t)
(rw_set_of_code f))
| While c b ->
{
add_r... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 1213,
"start_col": 0,
"start_line": 1184
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.Transformers.InstructionReorder.safely_bounded_code
-> Vale.Transformers.BoundedInstructionEffects.rw_set | Prims.Tot | [
"total"
] | [
"rw_set_of_code",
"rw_set_of_codes"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_code",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.Transformers.BoundedInstructionEffects.rw_set_of_ins",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.... | [
"mutual recursion"
] | false | false | false | true | false | let rec rw_set_of_code (c: safely_bounded_code) : rw_set =
| match c with
| Ins i -> rw_set_of_ins i
| Block l -> rw_set_of_codes l
| IfElse c t f ->
add_r_to_rw_set (locations_of_ocmp c) (rw_set_in_parallel (rw_set_of_code t) (rw_set_of_code f))
| While c b ->
{ add_r_to_rw_set (locations_of_ocmp c) (rw_set_of_code b) with loc_constant_writes = [] } | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux1 | 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... | 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... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 1296,
"start_col": 0,
"start_line": 1274
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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
... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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 (m... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_not_ok_propagate_codes | val lemma_not_ok_propagate_codes (l: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_codes l fuel s)))
(decreases %[fuel;l]) | val lemma_not_ok_propagate_codes (l: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_codes l fuel s)))
(decreases %[fuel;l]) | let rec lemma_not_ok_propagate_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel; c; 1]) =
match c with
| Ins _ -> reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins
| Block l ->
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1178,
"start_col": 0,
"start_line": 1139
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
l: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Prims.op_Negation (Mkmachine_state?.ms_ok s))
(ensures
Vale.Transformers.InstructionReorder.erroring_option_state (Vale.X64.Machine_Semantics_s.machi... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_not_ok_propagate_code",
"lemma_not_ok_propagate_codes",
"lemma_not_ok_propagate_while"
] | [
"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_not_ok_propagate... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_not_ok_propagate_codes (l: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_codes l fuel s)))
(decreases %[fuel;l]) =
| match l with
| [] -> ()
| x :: xs ->
lemma_not_ok_propagate_code x fuel s;
match machine_eval_code x fuel s with
| None -> ()
| Some s -> lemma_not_ok_propagate_codes xs fuel s | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_equiv_code_codes | 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 :: ... | 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 :: ... | 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)... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1272,
"start_col": 0,
"start_line": 1245
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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_... | FStar.Pervasives.Lemma | [
"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",
... | [] | false | false | true | false | 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 :: ... | 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
... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.rw_set_of_codes | val rw_set_of_codes (c: safely_bounded_codes) : rw_set | val rw_set_of_codes (c: safely_bounded_codes) : rw_set | let rec rw_set_of_code (c:safely_bounded_code) : rw_set =
match c with
| Ins i -> rw_set_of_ins i
| Block l -> rw_set_of_codes l
| IfElse c t f ->
add_r_to_rw_set
(locations_of_ocmp c)
(rw_set_in_parallel
(rw_set_of_code t)
(rw_set_of_code f))
| While c b ->
{
add_r... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 1213,
"start_col": 0,
"start_line": 1184
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.Transformers.InstructionReorder.safely_bounded_codes
-> Vale.Transformers.BoundedInstructionEffects.rw_set | Prims.Tot | [
"total"
] | [
"rw_set_of_code",
"rw_set_of_codes"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_codes",
"Vale.Transformers.BoundedInstructionEffects.Mkrw_set",
"Prims.Nil",
"Vale.Transformers.Locations.location",
"Vale.Transformers.BoundedInstructionEffects.location_with_value",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr... | [
"mutual recursion"
] | false | false | false | true | false | let rec rw_set_of_codes (c: safely_bounded_codes) : rw_set =
| match c with
| [] -> { loc_reads = []; loc_writes = []; loc_constant_writes = [] }
| x :: xs -> rw_set_in_series (rw_set_of_code x) (rw_set_of_codes xs) | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.main | val main: Prims.unit -> St C.exit_code | val main: Prims.unit -> St C.exit_code | let main () : St C.exit_code =
test_many C.String.(!$"[ECDSA SigVer]") test_sigver256 sigver_vectors256_low;
test_many C.String.(!$"[ECDSA SigGen]") test_siggen_256 siggen_vectors256_low;
test_many C.String.(!$"[ECDSA SigVer - SHA384]") test_sigver384 sigver_vectors384_low;
test_many C.String.(!$"[ECDSA SigGen... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 492,
"start_col": 0,
"start_line": 482
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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... | false | _: Prims.unit -> FStar.HyperStack.ST.St C.exit_code | FStar.HyperStack.ST.St | [] | [] | [
"Prims.unit",
"C.EXIT_SUCCESS",
"C.exit_code",
"Hacl.Test.ECDSA.test_many",
"FStar.Pervasives.Native.tuple7",
"Test.Lowstarize.lbuffer",
"FStar.UInt8.t",
"C.String.op_Bang_Dollar",
"Hacl.Test.ECDSA.test_siggen_512",
"Hacl.Test.ECDSA.siggen_vectors512_low",
"FStar.Pervasives.Native.tuple6",
"Pr... | [] | false | true | false | false | false | let main () : St C.exit_code =
| test_many C.String.(!$"[ECDSA SigVer]") test_sigver256 sigver_vectors256_low;
test_many C.String.(!$"[ECDSA SigGen]") test_siggen_256 siggen_vectors256_low;
test_many C.String.(!$"[ECDSA SigVer - SHA384]") test_sigver384 sigver_vectors384_low;
test_many C.String.(!$"[ECDSA SigGen - SHA384]") test_siggen_384 siggen_vect... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_constant_on_execution_stays_constant | 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 ==... | 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 ==... | 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) /\
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 979,
"start_col": 0,
"start_line": 867
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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) /\ (s2 ==... | 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, ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux4 | 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... | 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... | 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)) ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 1381,
"start_col": 0,
"start_line": 1357
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_not_ok_propagate_code | val lemma_not_ok_propagate_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;1]) | val lemma_not_ok_propagate_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;1]) | let rec lemma_not_ok_propagate_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel; c; 1]) =
match c with
| Ins _ -> reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins
| Block l ->
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1178,
"start_col": 0,
"start_line": 1139
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Prims.op_Negation (Mkmachine_state?.ms_ok s))
(ensures
Vale.Transformers.InstructionReorder.erroring_option_state (Vale.X64.Machine_Semantics_s.machin... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_not_ok_propagate_code",
"lemma_not_ok_propagate_codes",
"lemma_not_ok_propagate_while"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"FStar.Pervasives.reveal_opaque",
"Vale.X64.Machine_Semantics_s.ins",
"FStar.Pervasives.Native.option",
"Vale.X64.Ma... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_not_ok_propagate_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;1]) =
| match c with
| Ins _ -> reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins
| Block l -> lemma_not_ok_propagate_codes l fuel s
| IfElse ifCond ifTrue ifFalse ->
let s', b = machine_eval_ocmp s ifCond in
if b
then lemma_not_ok_propagate_code ifTrue fuel s'
else lemma_not_ok_propagate_code ifFalse fuel ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes | 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
... | 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
... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 1406,
"start_col": 0,
"start_line": 1383
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [] | false | false | true | false | 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
... | 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... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_not_ok_propagate_while | val lemma_not_ok_propagate_while (c: code{While? c}) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;0]) | val lemma_not_ok_propagate_while (c: code{While? c}) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;0]) | let rec lemma_not_ok_propagate_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel; c; 1]) =
match c with
| Ins _ -> reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins
| Block l ->
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1178,
"start_col": 0,
"start_line": 1139
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
c: Vale.X64.Machine_Semantics_s.code{While? c} ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Prims.op_Negation (Mkmachine_state?.ms_ok s))
(ensures
Vale.Transformers.InstructionReorder.erroring_option_state (Vale.X64.Machine_Semantic... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_not_ok_propagate_code",
"lemma_not_ok_propagate_codes",
"lemma_not_ok_propagate_while"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.b2t",
"Vale.X64.Machine_s.uu___is_While",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_Equality",
"Prims.int",
... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_not_ok_propagate_while (c: code{While? c}) (fuel: nat) (s: machine_state)
: Lemma (requires (not s.ms_ok))
(ensures (erroring_option_state (machine_eval_code c fuel s)))
(decreases %[fuel;c;0]) =
| if fuel = 0
then ()
else
(let While cond body = c in
let s, b = machine_eval_ocmp s cond in
if not b then () else (lemma_not_ok_propagate_code body (fuel - 1) s)) | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_sigver256 | val test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.re... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 128,
"start_col": 0,
"start_line": 97
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_E... | [] | false | true | false | false | false | let test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes_aux2 | 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
... | 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
... | 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)))
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 1320,
"start_col": 0,
"start_line": 1298
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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.... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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
... | 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
| [] ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.num_blocks_in_codes | val num_blocks_in_codes (c: codes) : nat | val num_blocks_in_codes (c: codes) : nat | 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 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 1520,
"start_col": 0,
"start_line": 1516
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.codes -> Prims.nat | Prims.Tot | [
"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... | [
"recursion"
] | false | false | false | true | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_num_blocks_in_codes_append | 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))] | 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 (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 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 1528,
"start_col": 0,
"start_line": 1522
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.split3 | val split3: #a:Type -> l:list a -> i:nat{i < L.length l} -> Tot (list a * a * list a) | val split3: #a:Type -> l:list a -> i:nat{i < L.length l} -> Tot (list a * a * list a) | 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 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 1572,
"start_col": 0,
"start_line": 1568
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | l: Prims.list a -> i: Prims.nat{i < FStar.List.Tot.Base.length l}
-> (Prims.list a * a) * Prims.list a | Prims.Tot | [
"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"
] | [] | false | false | false | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.bubble_to_top | 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 }) | 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, 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
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 1513,
"start_col": 0,
"start_line": 1486
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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'... | Prims.Tot | [
"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... | [
"recursion"
] | false | false | false | false | 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
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 " ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.aux_string_of_transformation_hints | val aux_string_of_transformation_hints (ts: transformation_hints) : Tot string (decreases %[ts;0]) | val aux_string_of_transformation_hints (ts: transformation_hints) : Tot string (decreases %[ts;0]) | let rec string_of_transformation_hint (th:transformation_hint) :
Tot string
(decreases %[th]) =
match th with
| MoveUpFrom p -> "(MoveUpFrom " ^ string_of_int p ^ ")"
| DiveInAt p q -> "(DiveInAt " ^ string_of_int p ^ " " ^ string_of_transformation_hint q ^ ")"
| InPlaceIfElse tr fa -> "(InPlaceIfElse " ^... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 1557,
"start_col": 0,
"start_line": 1538
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | ts: Vale.Transformers.InstructionReorder.transformation_hints -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [
"string_of_transformation_hint",
"aux_string_of_transformation_hints",
"string_of_transformation_hints"
] | [
"Vale.Transformers.InstructionReorder.transformation_hints",
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.list",
"Prims.op_Hat",
"Vale.Transformers.InstructionReorder.string_of_transformation_hint",
"Vale.Transformers.InstructionReorder.aux_string_of_transformation_hints",
"Prims.s... | [
"mutual recursion"
] | false | false | false | true | false | let rec aux_string_of_transformation_hints (ts: transformation_hints)
: Tot string (decreases %[ts;0]) =
| match ts with
| [] -> ""
| x :: xs -> string_of_transformation_hint x ^ "; " ^ aux_string_of_transformation_hints xs | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_code | val lemma_bounded_code (c: safely_bounded_code) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_code c) (wrap_sos (machine_eval_code c fuel))))
(decreases %[c]) | val lemma_bounded_code (c: safely_bounded_code) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_code c) (wrap_sos (machine_eval_code c fuel))))
(decreases %[c]) | let rec lemma_bounded_code (c:safely_bounded_code) (fuel:nat) :
Lemma
(ensures (bounded_effects (rw_set_of_code c) (wrap_sos (machine_eval_code c fuel))))
(decreases %[c]) =
match c with
| Ins i ->
reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins;
lemma_machine_eval_code_Ins_bounded_e... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 1444,
"start_col": 0,
"start_line": 1408
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.Transformers.InstructionReorder.safely_bounded_code -> fuel: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.BoundedInstructionEffects.bounded_effects (Vale.Transformers.InstructionReorder.rw_set_of_code
c)
(Vale.Transformers.InstructionReorder.wrap_sos (Va... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_bounded_code",
"lemma_bounded_codes"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_code",
"Prims.nat",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.Transformers.InstructionReorder.lemma_bounded_effects_on_functional_extensionality",
"Vale.Transformers.BoundedInstructionEffects.rw_set_of... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_bounded_code (c: safely_bounded_code) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_code c) (wrap_sos (machine_eval_code c fuel))))
(decreases %[c]) =
| match c with
| Ins i ->
reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins;
lemma_machine_eval_code_Ins_bounded_effects i fuel;
lemma_bounded_effects_on_functional_extensionality (rw_set_of_ins i)
(fun s -> (), (Some?.v (machine_eval_code_ins_def i s)))
(wrap_sos (machine_eval_code c fuel))
| B... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.wrap_diveinat | val wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints | val wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints | let rec wrap_diveinat (p:nat) (l:transformation_hints) : transformation_hints =
match l with
| [] -> []
| x :: xs ->
DiveInAt p x :: wrap_diveinat p xs | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 1563,
"start_col": 0,
"start_line": 1559
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | p: Prims.nat -> l: Vale.Transformers.InstructionReorder.transformation_hints
-> Vale.Transformers.InstructionReorder.transformation_hints | Prims.Tot | [
"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"
] | [
"recursion"
] | false | false | false | true | false | let rec wrap_diveinat (p: nat) (l: transformation_hints) : transformation_hints =
| match l with
| [] -> []
| x :: xs -> DiveInAt p x :: wrap_diveinat p xs | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.string_of_transformation_hints | val string_of_transformation_hints (ts: transformation_hints) : Tot string (decreases %[ts;1]) | val string_of_transformation_hints (ts: transformation_hints) : Tot string (decreases %[ts;1]) | let rec string_of_transformation_hint (th:transformation_hint) :
Tot string
(decreases %[th]) =
match th with
| MoveUpFrom p -> "(MoveUpFrom " ^ string_of_int p ^ ")"
| DiveInAt p q -> "(DiveInAt " ^ string_of_int p ^ " " ^ string_of_transformation_hint q ^ ")"
| InPlaceIfElse tr fa -> "(InPlaceIfElse " ^... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 1557,
"start_col": 0,
"start_line": 1538
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | ts: Vale.Transformers.InstructionReorder.transformation_hints -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [
"string_of_transformation_hint",
"aux_string_of_transformation_hints",
"string_of_transformation_hints"
] | [
"Vale.Transformers.InstructionReorder.transformation_hints",
"Prims.op_Hat",
"Vale.Transformers.InstructionReorder.aux_string_of_transformation_hints",
"Prims.string"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec string_of_transformation_hints (ts: transformation_hints) : Tot string (decreases %[ts;1]) =
| "[" ^ aux_string_of_transformation_hints ts ^ "]" | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.is_empty_codes | val is_empty_codes (c: codes) : bool | val is_empty_codes (c: codes) : bool | let rec is_empty_code (c:code) : bool =
match c with
| Ins _ -> false
| Block l -> is_empty_codes l
| IfElse _ t f -> false
| While _ c -> false
and is_empty_codes (c:codes) : bool =
match c with
| [] -> true
| x :: xs -> is_empty_code x && is_empty_codes xs | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 1584,
"start_col": 0,
"start_line": 1574
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.codes -> Prims.bool | Prims.Tot | [
"total"
] | [
"is_empty_code",
"is_empty_codes"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Prims.op_AmpAmp",
"Vale.Transformers.InstructionReorder.is_empty_code",
"Vale.Transformers.InstructionReorder.is_empty_codes",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec is_empty_codes (c: codes) : bool =
| match c with
| [] -> true
| x :: xs -> is_empty_code x && is_empty_codes xs | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.fully_unblocked_code | val fully_unblocked_code (c: code) : codes | val fully_unblocked_code (c: code) : codes | let rec fully_unblocked_code (c:code) : codes =
match c with
| Ins i -> [c]
| Block l -> fully_unblocked_codes l
| IfElse c t f -> [IfElse c (Block (fully_unblocked_code t)) (Block (fully_unblocked_code f))]
| While c b -> [While c (Block (fully_unblocked_code b))]
and fully_unblocked_codes (c:codes) : codes... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 1724,
"start_col": 0,
"start_line": 1713
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> Vale.X64.Machine_Semantics_s.codes | Prims.Tot | [
"total"
] | [
"fully_unblocked_code",
"fully_unblocked_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.Cons",
"Vale.X64.Bytes_Code_s.code_t",
"Prims.Nil",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.InstructionReorder.fu... | [
"mutual recursion"
] | false | false | false | true | false | let rec fully_unblocked_code (c: code) : codes =
| match c with
| Ins i -> [c]
| Block l -> fully_unblocked_codes l
| IfElse c t f -> [IfElse c (Block (fully_unblocked_code t)) (Block (fully_unblocked_code f))]
| While c b -> [While c (Block (fully_unblocked_code b))] | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_metric_for_codes_append | 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))] | 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.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 | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 1788,
"start_col": 0,
"start_line": 1782
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_code_exchange_allowed | 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))) | 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: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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 1478,
"start_col": 0,
"start_line": 1454
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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_... | [] | false | false | true | false | 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 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 ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.perform_reordering_with_hint | val perform_reordering_with_hint (t: transformation_hint) (c: codes) : possibly codes | val perform_reordering_with_hint (t: transformation_hint) (c: codes) : possibly codes | let rec perform_reordering_with_hint (t:transformation_hint) (c:codes) : possibly codes =
match c with
| [] -> Err "trying to transform empty code"
| x :: xs ->
if is_empty_codes [x] then perform_reordering_with_hint t xs else (
match t with
| MoveUpFrom i -> (
if i < L.length c then (
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 1677,
"start_col": 0,
"start_line": 1586
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | t: Vale.Transformers.InstructionReorder.transformation_hint -> c: Vale.X64.Machine_Semantics_s.codes
-> Vale.Def.PossiblyMonad.possibly Vale.X64.Machine_Semantics_s.codes | Prims.Tot | [
"total"
] | [
"perform_reordering_with_hint",
"perform_reordering_with_hints"
] | [
"Vale.Transformers.InstructionReorder.transformation_hint",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Def.PossiblyMonad.Err",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.Transformers.InstructionReorder.is_empty_codes",
"Prims.Cons",
"Prims.N... | [
"mutual recursion"
] | false | false | false | true | false | let rec perform_reordering_with_hint (t: transformation_hint) (c: codes) : possibly codes =
| match c with
| [] -> Err "trying to transform empty code"
| x :: xs ->
if is_empty_codes [x]
then perform_reordering_with_hint t xs
else
(match t with
| MoveUpFrom i ->
(if i < L.length c
then
(let+ c' = bubble_to_top c i in
return (L.index c i :: c'))
... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.increment_hint | val increment_hint (th: transformation_hint) : transformation_hint | val increment_hint (th: transformation_hint) : transformation_hint | let increment_hint (th:transformation_hint) : transformation_hint =
match th with
| MoveUpFrom p -> MoveUpFrom (p + 1)
| DiveInAt p q -> DiveInAt (p + 1) q
| _ -> th | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 1730,
"start_col": 0,
"start_line": 1726
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | th: Vale.Transformers.InstructionReorder.transformation_hint
-> Vale.Transformers.InstructionReorder.transformation_hint | Prims.Tot | [
"total"
] | [] | [
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.nat",
"Vale.Transformers.InstructionReorder.MoveUpFrom",
"Prims.op_Addition",
"Vale.Transformers.InstructionReorder.DiveInAt"
] | [] | false | false | false | true | 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 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.eq_codes | val eq_codes (c1 c2: codes) : bool | val eq_codes (c1 c2: codes) : bool | let rec eq_code (c1 c2:code) : bool =
match c1, c2 with
| Ins i1, Ins i2 -> eq_ins i1 i2
| Block l1, Block l2 -> eq_codes l1 l2
| IfElse c1 t1 f1, IfElse c2 t2 f2 -> c1 = c2 && eq_code t1 t2 && eq_code f1 f2
| While c1 b1, While c2 b2 -> c1 = c2 && eq_code b1 b2
| _, _ -> false
and eq_codes (c1 c2:codes) :... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 1711,
"start_col": 0,
"start_line": 1697
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c1: Vale.X64.Machine_Semantics_s.codes -> c2: Vale.X64.Machine_Semantics_s.codes -> Prims.bool | Prims.Tot | [
"total"
] | [
"eq_code",
"eq_codes"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.op_AmpAmp",
"Vale.Transformers.InstructionReorder.eq_code",
"Vale.Transformers.InstructionReorder.eq_codes",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec eq_codes (c1 c2: codes) : bool =
| match c1, c2 with
| [], [] -> true
| _, [] | [], _ -> false
| x :: xs, y :: ys -> eq_code x y && eq_codes xs ys | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.perform_reordering_with_hints | val perform_reordering_with_hints (ts: transformation_hints) (c: codes) : possibly codes | val perform_reordering_with_hints (ts: transformation_hints) (c: codes) : possibly codes | let rec perform_reordering_with_hint (t:transformation_hint) (c:codes) : possibly codes =
match c with
| [] -> Err "trying to transform empty code"
| x :: xs ->
if is_empty_codes [x] then perform_reordering_with_hint t xs else (
match t with
| MoveUpFrom i -> (
if i < L.length c then (
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 1677,
"start_col": 0,
"start_line": 1586
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
ts: Vale.Transformers.InstructionReorder.transformation_hints ->
c: Vale.X64.Machine_Semantics_s.codes
-> Vale.Def.PossiblyMonad.possibly Vale.X64.Machine_Semantics_s.codes | Prims.Tot | [
"total"
] | [
"perform_reordering_with_hint",
"perform_reordering_with_hints"
] | [
"Vale.Transformers.InstructionReorder.transformation_hints",
"Vale.X64.Machine_Semantics_s.codes",
"Vale.Transformers.InstructionReorder.is_empty_codes",
"Vale.Def.PossiblyMonad.return",
"Prims.Nil",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.bool",
"Vale... | [
"mutual recursion"
] | false | false | false | true | false | let rec perform_reordering_with_hints (ts: transformation_hints) (c: codes) : possibly codes =
| match ts with
| [] ->
(if is_empty_codes c
then (return [])
else (Err ("no more transformation hints for " ^ fst (print_code (Block c) 0 gcc))))
| t :: ts' ->
let+ c' = perform_reordering_with_hint t c in
match c' with
| [] -> Err "impossible"
| x :: xs ->
if is_empty_codes [x]
then (Err "Tryi... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.is_empty_code | val is_empty_code (c: code) : bool | val is_empty_code (c: code) : bool | let rec is_empty_code (c:code) : bool =
match c with
| Ins _ -> false
| Block l -> is_empty_codes l
| IfElse _ t f -> false
| While _ c -> false
and is_empty_codes (c:codes) : bool =
match c with
| [] -> true
| x :: xs -> is_empty_code x && is_empty_codes xs | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 1584,
"start_col": 0,
"start_line": 1574
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> Prims.bool | Prims.Tot | [
"total"
] | [
"is_empty_code",
"is_empty_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.InstructionReorder.is_empty_codes",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec is_empty_code (c: code) : bool =
| match c with
| Ins _ -> false
| Block l -> is_empty_codes l
| IfElse _ t f -> false
| While _ c -> false | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.eq_code | val eq_code (c1 c2: code) : bool | val eq_code (c1 c2: code) : bool | let rec eq_code (c1 c2:code) : bool =
match c1, c2 with
| Ins i1, Ins i2 -> eq_ins i1 i2
| Block l1, Block l2 -> eq_codes l1 l2
| IfElse c1 t1 f1, IfElse c2 t2 f2 -> c1 = c2 && eq_code t1 t2 && eq_code f1 f2
| While c1 b1, While c2 b2 -> c1 = c2 && eq_code b1 b2
| _, _ -> false
and eq_codes (c1 c2:codes) :... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 1711,
"start_col": 0,
"start_line": 1697
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c1: Vale.X64.Machine_Semantics_s.code -> c2: Vale.X64.Machine_Semantics_s.code -> Prims.bool | Prims.Tot | [
"total"
] | [
"eq_code",
"eq_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"FStar.Pervasives.Native.Mktuple2",
"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.Transformers.InstructionReorder.eq_ins",
"Prims.list",
"Vale.Transformers... | [
"mutual recursion"
] | false | false | false | true | false | let rec eq_code (c1 c2: code) : bool =
| match c1, c2 with
| Ins i1, Ins i2 -> eq_ins i1 i2
| Block l1, Block l2 -> eq_codes l1 l2
| IfElse c1 t1 f1, IfElse c2 t2 f2 -> c1 = c2 && eq_code t1 t2 && eq_code f1 f2
| While c1 b1, While c2 b2 -> c1 = c2 && eq_code b1 b2
| _, _ -> false | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_is_empty_codes | val lemma_is_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_codes cs))
(ensures ((machine_eval_codes cs fuel s) == (machine_eval_codes [] fuel s))) | val lemma_is_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_codes cs))
(ensures ((machine_eval_codes cs fuel s) == (machine_eval_codes [] fuel s))) | let rec lemma_is_empty_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(requires (is_empty_code c))
(ensures ((machine_eval_code c fuel s) == (machine_eval_codes [] fuel s))) =
match c with
| Ins _ -> ()
| Block l -> lemma_is_empty_codes l fuel s
| IfElse _ t f -> ()
| While _ c -> ()
and lemma_i... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 1963,
"start_col": 0,
"start_line": 1946
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
cs: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Vale.Transformers.InstructionReorder.is_empty_codes cs)
(ensures
Vale.X64.Machine_Semantics_s.machine_eval_codes cs fuel s ==
Vale.X64.Machi... | FStar.Pervasives.Lemma | [
"lemma"
] | [
"lemma_is_empty_code",
"lemma_is_empty_codes"
] | [
"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.Transformers.InstructionReorder.lemma_is_empty_codes",
"Prims.unit",
"Vale.Transformers.InstructionReo... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_is_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_codes cs))
(ensures ((machine_eval_codes cs fuel s) == (machine_eval_codes [] fuel s))) =
| match cs with
| [] -> ()
| x :: xs ->
lemma_is_empty_code x fuel s;
lemma_is_empty_codes xs fuel s | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.string_of_transformation_hint | val string_of_transformation_hint (th: transformation_hint) : Tot string (decreases %[th]) | val string_of_transformation_hint (th: transformation_hint) : Tot string (decreases %[th]) | let rec string_of_transformation_hint (th:transformation_hint) :
Tot string
(decreases %[th]) =
match th with
| MoveUpFrom p -> "(MoveUpFrom " ^ string_of_int p ^ ")"
| DiveInAt p q -> "(DiveInAt " ^ string_of_int p ^ " " ^ string_of_transformation_hint q ^ ")"
| InPlaceIfElse tr fa -> "(InPlaceIfElse " ^... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 1557,
"start_col": 0,
"start_line": 1538
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | th: Vale.Transformers.InstructionReorder.transformation_hint -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [
"string_of_transformation_hint",
"aux_string_of_transformation_hints",
"string_of_transformation_hints"
] | [
"Vale.Transformers.InstructionReorder.transformation_hint",
"Prims.nat",
"Prims.op_Hat",
"Prims.string_of_int",
"Vale.Transformers.InstructionReorder.string_of_transformation_hint",
"Prims.list",
"Vale.Transformers.InstructionReorder.string_of_transformation_hints",
"Prims.string"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec string_of_transformation_hint (th: transformation_hint) : Tot string (decreases %[th]) =
| match th with
| MoveUpFrom p -> "(MoveUpFrom " ^ string_of_int p ^ ")"
| DiveInAt p q -> "(DiveInAt " ^ string_of_int p ^ " " ^ string_of_transformation_hint q ^ ")"
| InPlaceIfElse tr fa ->
"(InPlaceIfElse " ^
string_of_transformation_hints tr ^ " " ^ string_of_transformation_hints fa ^ ")"
| InPlaceWhile bo -> "(... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_is_empty_code | val lemma_is_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_code c))
(ensures ((machine_eval_code c fuel s) == (machine_eval_codes [] fuel s))) | val lemma_is_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_code c))
(ensures ((machine_eval_code c fuel s) == (machine_eval_codes [] fuel s))) | let rec lemma_is_empty_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(requires (is_empty_code c))
(ensures ((machine_eval_code c fuel s) == (machine_eval_codes [] fuel s))) =
match c with
| Ins _ -> ()
| Block l -> lemma_is_empty_codes l fuel s
| IfElse _ t f -> ()
| While _ c -> ()
and lemma_i... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 1963,
"start_col": 0,
"start_line": 1946
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires Vale.Transformers.InstructionReorder.is_empty_code c)
(ensures
Vale.X64.Machine_Semantics_s.machine_eval_code c fuel s ==
Vale.X64.Machine_Sem... | FStar.Pervasives.Lemma | [
"lemma"
] | [
"lemma_is_empty_code",
"lemma_is_empty_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.InstructionReorder.lemm... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_is_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (requires (is_empty_code c))
(ensures ((machine_eval_code c fuel s) == (machine_eval_codes [] fuel s))) =
| match c with
| Ins _ -> ()
| Block l -> lemma_is_empty_codes l fuel s
| IfElse _ t f -> ()
| While _ c -> () | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bounded_codes | val lemma_bounded_codes (c: safely_bounded_codes) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_codes c) (wrap_sos (machine_eval_codes c fuel))))
(decreases %[c]) | val lemma_bounded_codes (c: safely_bounded_codes) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_codes c) (wrap_sos (machine_eval_codes c fuel))))
(decreases %[c]) | let rec lemma_bounded_code (c:safely_bounded_code) (fuel:nat) :
Lemma
(ensures (bounded_effects (rw_set_of_code c) (wrap_sos (machine_eval_code c fuel))))
(decreases %[c]) =
match c with
| Ins i ->
reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins;
lemma_machine_eval_code_Ins_bounded_e... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 1444,
"start_col": 0,
"start_line": 1408
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.Transformers.InstructionReorder.safely_bounded_codes -> fuel: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.BoundedInstructionEffects.bounded_effects (Vale.Transformers.InstructionReorder.rw_set_of_codes
c)
(Vale.Transformers.InstructionReorder.wrap_sos (... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_bounded_code",
"lemma_bounded_codes"
] | [
"Vale.Transformers.InstructionReorder.safely_bounded_codes",
"Prims.nat",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.Transformers.InstructionReorder.lemma_bounded_effects_code_codes",
"Vale.Transformers.InstructionReorder.rw_set_of_codes",
"Pri... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_bounded_codes (c: safely_bounded_codes) (fuel: nat)
: Lemma (ensures (bounded_effects (rw_set_of_codes c) (wrap_sos (machine_eval_codes c fuel))))
(decreases %[c]) =
| let open Vale.X64.Machine_Semantics_s in
match c with
| [] -> ()
| x :: xs ->
lemma_bounded_code x fuel;
lemma_bounded_codes xs fuel;
lemma_bounded_effects_series (rw_set_of_code x)
(rw_set_of_codes xs)
(wrap_sos (machine_eval_code x fuel))
(wrap_sos (machine_eval_codes xs fuel));
lemma_bounded_effe... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_machine_eval_codes_block_to_append | 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)) | 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) :
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 -> ()
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 1932,
"start_col": 0,
"start_line": 1923
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 -> ()
| Some s1 -> lemma_machine_eval_codes_block_to_append xs c2 fuel s1 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.metric_for_codes | val metric_for_codes (c: codes) : GTot nat | val metric_for_codes (c: codes) : GTot nat | let rec metric_for_code (c:code) : GTot nat =
1 + (
match c with
| Ins _ -> 0
| Block l -> metric_for_codes l
| IfElse _ t f -> metric_for_code t + metric_for_code f
| While _ b -> metric_for_code b
)
and metric_for_codes (c:codes) : GTot nat =
match c with
| [] -> 0
| x :: xs -> 1 + metr... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 1780,
"start_col": 0,
"start_line": 1768
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.codes -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [
"metric_for_code",
"metric_for_codes"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Prims.op_Addition",
"Vale.Transformers.InstructionReorder.metric_for_code",
"Vale.Transformers.InstructionReorder.metric_for_codes",
"Prims.nat"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec metric_for_codes (c: codes) : GTot nat =
| match c with
| [] -> 0
| x :: xs -> 1 + metric_for_code x + metric_for_codes xs | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.purge_empty_codes | val purge_empty_codes (cs: codes) : codes | val purge_empty_codes (cs: codes) : codes | let rec purge_empty_code (c:code) : code =
match c with
| Block l ->
Block (purge_empty_codes l)
| IfElse c t f ->
IfElse c (purge_empty_code t) (purge_empty_code f)
| While c b ->
While c (purge_empty_code b)
| _ ->
c
and purge_empty_codes (cs:codes) : codes =
match cs with
| [] -> []
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 2151,
"start_col": 0,
"start_line": 2132
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | cs: Vale.X64.Machine_Semantics_s.codes -> Vale.X64.Machine_Semantics_s.codes | Prims.Tot | [
"total"
] | [
"purge_empty_code",
"purge_empty_codes"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.Nil",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.Transformers.InstructionReorder.is_empty_code",
"Vale.Transformers.InstructionReorder.purge_empty_codes",
"Prims.bool",
"Prims.Cons",
"Vale.Transf... | [
"mutual recursion"
] | false | false | false | true | false | let rec purge_empty_codes (cs: codes) : codes =
| match cs with
| [] -> []
| x :: xs ->
if is_empty_code x then (purge_empty_codes xs) else (purge_empty_code x :: purge_empty_codes xs) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.metric_for_code | val metric_for_code (c: code) : GTot nat | val metric_for_code (c: code) : GTot nat | let rec metric_for_code (c:code) : GTot nat =
1 + (
match c with
| Ins _ -> 0
| Block l -> metric_for_codes l
| IfElse _ t f -> metric_for_code t + metric_for_code f
| While _ b -> metric_for_code b
)
and metric_for_codes (c:codes) : GTot nat =
match c with
| [] -> 0
| x :: xs -> 1 + metr... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 1780,
"start_col": 0,
"start_line": 1768
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [
"metric_for_code",
"metric_for_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.op_Addition",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.Transformers.InstructionReorder.metric_for_codes",
"Vale.Transformers.Inst... | [
"mutual recursion"
] | false | false | false | false | false | let rec metric_for_code (c: code) : GTot nat =
| 1 +
(match c with
| Ins _ -> 0
| Block l -> metric_for_codes l
| IfElse _ t f -> metric_for_code t + metric_for_code f
| While _ b -> metric_for_code b) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.fully_unblocked_codes | val fully_unblocked_codes (c: codes) : codes | val fully_unblocked_codes (c: codes) : codes | let rec fully_unblocked_code (c:code) : codes =
match c with
| Ins i -> [c]
| Block l -> fully_unblocked_codes l
| IfElse c t f -> [IfElse c (Block (fully_unblocked_code t)) (Block (fully_unblocked_code f))]
| While c b -> [While c (Block (fully_unblocked_code b))]
and fully_unblocked_codes (c:codes) : codes... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 1724,
"start_col": 0,
"start_line": 1713
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.codes -> Vale.X64.Machine_Semantics_s.codes | Prims.Tot | [
"total"
] | [
"fully_unblocked_code",
"fully_unblocked_codes"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.Nil",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"FStar.List.Tot.Base.append",
"Vale.Transformers.InstructionReorder.fully_unblocked_code",
"Vale.Transformers.InstructionReorder.fully_unblocked_codes"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec fully_unblocked_codes (c: codes) : codes =
| match c with
| [] -> []
| x :: xs -> (fully_unblocked_code x) `L.append` (fully_unblocked_codes xs) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.find_deep_code_transform | val find_deep_code_transform (c: code) (cs: codes) : possibly transformation_hint | 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 =
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"... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 1766,
"start_col": 0,
"start_line": 1732
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> cs: Vale.X64.Machine_Semantics_s.codes
-> Vale.Def.PossiblyMonad.possibly Vale.Transformers.InstructionReorder.transformation_hint | Prims.Tot | [
"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",
... | [
"recursion"
] | false | false | false | true | 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 ->
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
... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.purge_empty_code | val purge_empty_code (c: code) : code | val purge_empty_code (c: code) : code | let rec purge_empty_code (c:code) : code =
match c with
| Block l ->
Block (purge_empty_codes l)
| IfElse c t f ->
IfElse c (purge_empty_code t) (purge_empty_code f)
| While c b ->
While c (purge_empty_code b)
| _ ->
c
and purge_empty_codes (cs:codes) : codes =
match cs with
| [] -> []
... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 2151,
"start_col": 0,
"start_line": 2132
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | c: Vale.X64.Machine_Semantics_s.code -> Vale.X64.Machine_Semantics_s.code | Prims.Tot | [
"total"
] | [
"purge_empty_code",
"purge_empty_codes"
] | [
"Vale.X64.Machine_Semantics_s.code",
"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.Machine_s.Block",
"Vale.Transformers.InstructionReorder.purge_empty_codes",
"Vale.X64.Machi... | [
"mutual recursion"
] | false | false | false | true | false | let rec purge_empty_code (c: code) : code =
| match c with
| Block l -> Block (purge_empty_codes l)
| IfElse c t f -> IfElse c (purge_empty_code t) (purge_empty_code f)
| While c b -> While c (purge_empty_code b)
| _ -> c | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_append_single | 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)) | 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))
(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) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 1943,
"start_col": 0,
"start_line": 1935
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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) | FStar.Pervasives.Lemma | [
"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",
... | [
"recursion"
] | false | false | true | false | 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) | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_sigver384 | val test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.re... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 162,
"start_col": 0,
"start_line": 131
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_E... | [] | false | true | false | false | false | let test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_purge_empty_code | val lemma_purge_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel;c;1]) | val lemma_purge_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel;c;1]) | let rec lemma_purge_empty_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel; c; 1]) =
match c with
| Block l -> lemma_purge_empty_codes l fuel s
| IfElse c t f ->
let (s', b) = machine_eval_ocm... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 2201,
"start_col": 0,
"start_line": 2154
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"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... | false |
c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(ensures
Vale.X64.Machine_Semantics_s.machine_eval_code c fuel s ==
Vale.X64.Machine_Semantics_s.machine_eval_code (Vale.Transformers.InstructionReorder... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_purge_empty_code",
"lemma_purge_empty_codes",
"lemma_purge_empty_while"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"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.Transformers.InstructionReorder.lemm... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_purge_empty_code (c: code) (fuel: nat) (s: machine_state)
: Lemma (ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel;c;1]) =
| match c with
| Block l -> lemma_purge_empty_codes l fuel s
| IfElse c t f ->
let s', b = machine_eval_ocmp s c in
if b then lemma_purge_empty_code t fuel s' else lemma_purge_empty_code f fuel s'
| While _ _ -> lemma_purge_empty_while c fuel s
| _ -> () | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_purge_empty_while | val lemma_purge_empty_while (c: code{While? c}) (fuel: nat) (s0: machine_state)
: Lemma
(ensures (machine_eval_code c fuel s0 == machine_eval_code (purge_empty_code c) fuel s0))
(decreases %[fuel;c;0]) | val lemma_purge_empty_while (c: code{While? c}) (fuel: nat) (s0: machine_state)
: Lemma
(ensures (machine_eval_code c fuel s0 == machine_eval_code (purge_empty_code c) fuel s0))
(decreases %[fuel;c;0]) | let rec lemma_purge_empty_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel; c; 1]) =
match c with
| Block l -> lemma_purge_empty_codes l fuel s
| IfElse c t f ->
let (s', b) = machine_eval_ocm... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 2201,
"start_col": 0,
"start_line": 2154
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"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... | false |
c: Vale.X64.Machine_Semantics_s.code{While? c} ->
fuel: Prims.nat ->
s0: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(ensures
Vale.X64.Machine_Semantics_s.machine_eval_code c fuel s0 ==
Vale.X64.Machine_Semantics_s.machine_eval_code (Vale.Transformers.Instru... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_purge_empty_code",
"lemma_purge_empty_codes",
"lemma_purge_empty_while"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.b2t",
"Vale.X64.Machine_s.uu___is_While",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_Equality",
"Prims.int",
... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_purge_empty_while (c: code{While? c}) (fuel: nat) (s0: machine_state)
: Lemma
(ensures (machine_eval_code c fuel s0 == machine_eval_code (purge_empty_code c) fuel s0))
(decreases %[fuel;c;0]) =
| if fuel = 0
then ()
else
(let While cond body = c in
let s0, b = machine_eval_ocmp s0 cond in
if not b
then ()
else
let s_opt = machine_eval_code body (fuel - 1) s0 in
lemma_purge_empty_code body (fuel - 1) s0;
match s_opt with
| None -> ()
| Some s1 -> if s1.ms_ok then l... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_bubble_to_top | 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
... | 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
... | 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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 1919,
"start_col": 0,
"start_line": 1887
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
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... | FStar.Pervasives.Lemma | [
"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... | [
"recursion"
] | false | false | true | false | 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 cs i in
... | 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_... | false |
MiniParse.Spec.Int.Aux.fst | MiniParse.Spec.Int.Aux.encode_u16 | val encode_u16 (x: U16.t) : Tot (U8.t * U8.t) | val encode_u16 (x: U16.t) : Tot (U8.t * U8.t) | let encode_u16 (x: U16.t) : Tot (U8.t * U8.t) =
let lo = Cast.uint16_to_uint8 x in
let hi = Cast.uint16_to_uint8 (x `U16.div` 256us) in
(lo, hi) | {
"file_name": "examples/miniparse/MiniParse.Spec.Int.Aux.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 31,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Int.Aux... | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Mi... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt16.t -> FStar.UInt8.t * FStar.UInt8.t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt16.t",
"FStar.Pervasives.Native.Mktuple2",
"FStar.UInt8.t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.UInt8.v",
"Prims.op_Modulus",
"FStar.UInt16.v",
"FStar.UInt16.div",
"FStar.UInt16.uint_to_t",
"Prims.pow2",
"FStar.Int.Cast.uint16_to_uint8",
"FStar.UInt16.__uint_to... | [] | false | false | false | true | false | let encode_u16 (x: U16.t) : Tot (U8.t * U8.t) =
| let lo = Cast.uint16_to_uint8 x in
let hi = Cast.uint16_to_uint8 (x `U16.div` 256us) in
(lo, hi) | false |
MiniParse.Spec.Int.Aux.fst | MiniParse.Spec.Int.Aux.decode_u16 | val decode_u16 (lohi: (U8.t * U8.t)) : Tot U16.t | val decode_u16 (lohi: (U8.t * U8.t)) : Tot U16.t | let decode_u16 (lohi: U8.t * U8.t) : Tot U16.t =
let (lo, hi) = lohi in
Cast.uint8_to_uint16 lo `U16.add` (256us `U16.mul` Cast.uint8_to_uint16 hi) | {
"file_name": "examples/miniparse/MiniParse.Spec.Int.Aux.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 77,
"end_line": 25,
"start_col": 0,
"start_line": 23
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Int.Aux... | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Mi... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | lohi: (FStar.UInt8.t * FStar.UInt8.t) -> FStar.UInt16.t | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.UInt8.t",
"FStar.UInt16.add",
"FStar.Int.Cast.uint8_to_uint16",
"FStar.UInt16.mul",
"FStar.UInt16.__uint_to_t",
"FStar.UInt16.t"
] | [] | false | false | false | true | false | let decode_u16 (lohi: U8.t * U8.t) : Tot U16.t =
| let lo, hi = lohi in
(Cast.uint8_to_uint16 lo) `U16.add` (256us `U16.mul` (Cast.uint8_to_uint16 hi)) | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.find_transformation_hints | val find_transformation_hints (c1 c2: codes)
: Tot (possibly transformation_hints) (decreases %[metric_for_codes c2;metric_for_codes c1]) | 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]) =
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... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 1881,
"start_col": 0,
"start_line": 1796
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false | 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) | Prims.Tot | [
"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... | [
"recursion"
] | false | false | false | true | 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 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 :... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_eval_code_equiv_states | val lemma_eval_code_equiv_states (c: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_code c fuel s1, machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;c]) | val lemma_eval_code_equiv_states (c: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_code c fuel s1, machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;c]) | let rec lemma_eval_code_equiv_states (c : code) (fuel:nat) (s1 s2 : machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
let s1'', s2'' =
machine_eval_code c fuel s1,
machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel; c]) =
match ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 504,
"start_col": 0,
"start_line": 423
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
c: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
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
(let _ =
Vale.X64... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_eval_code_equiv_states",
"lemma_eval_codes_equiv_states",
"lemma_eval_while_equiv_states"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.Transformers.InstructionReorder.lemma_eval_ins_equiv_states",
"Vale.Transformers.InstructionReorder.filt_state",
... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_eval_code_equiv_states (c: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_code c fuel s1, machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;c]) =
| match c with
| Ins ins ->
reveal_opaque (`%machine_eval_code_ins) machine_eval_code_ins;
lemma_eval_ins_equiv_states ins (filt_state s1) (filt_state s2)
| Block l -> lemma_eval_codes_equiv_states l fuel s1 s2
| IfElse ifCond ifTrue ifFalse ->
reveal_opaque (`%valid_ocmp_opaque) valid_ocmp_opaque;
reveal_opaque ... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_eval_codes_equiv_states | val lemma_eval_codes_equiv_states (cs: codes) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_codes cs fuel s1, machine_eval_codes cs fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;cs]) | val lemma_eval_codes_equiv_states (cs: codes) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_codes cs fuel s1, machine_eval_codes cs fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;cs]) | let rec lemma_eval_code_equiv_states (c : code) (fuel:nat) (s1 s2 : machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
let s1'', s2'' =
machine_eval_code c fuel s1,
machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel; c]) =
match ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 504,
"start_col": 0,
"start_line": 423
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
cs: Vale.X64.Machine_Semantics_s.codes ->
fuel: Prims.nat ->
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
(let _ =
Vale.X... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_eval_code_equiv_states",
"lemma_eval_codes_equiv_states",
"lemma_eval_while_equiv_states"
] | [
"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",
"FStar.Pervasives.Native.option",
"Vale.Transformers.InstructionReorder.lemma_eval_codes_equiv_states",
"Pri... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_eval_codes_equiv_states (cs: codes) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(let s1'', s2'' = machine_eval_codes cs fuel s1, machine_eval_codes cs fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel;cs]) =
| match cs with
| [] -> ()
| c :: cs ->
lemma_eval_code_equiv_states c fuel s1 s2;
let s1'', s2'' = machine_eval_code c fuel s1, machine_eval_code c fuel s2 in
match s1'' with
| None -> ()
| _ ->
let Some s1, Some s2 = s1'', s2'' in
lemma_eval_codes_equiv_states cs fuel s1 s2 | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_purge_empty_codes | val lemma_purge_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures (machine_eval_codes cs fuel s == machine_eval_codes (purge_empty_codes cs) fuel s))
(decreases %[fuel;cs]) | val lemma_purge_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures (machine_eval_codes cs fuel s == machine_eval_codes (purge_empty_codes cs) fuel s))
(decreases %[fuel;cs]) | let rec lemma_purge_empty_code (c:code) (fuel:nat) (s:machine_state) :
Lemma
(ensures (machine_eval_code c fuel s == machine_eval_code (purge_empty_code c) fuel s))
(decreases %[fuel; c; 1]) =
match c with
| Block l -> lemma_purge_empty_codes l fuel s
| IfElse c t f ->
let (s', b) = machine_eval_ocm... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 2201,
"start_col": 0,
"start_line": 2154
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"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... | false |
cs: 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 cs fuel s ==
Vale.X64.Machine_Semantics_s.machine_eval_codes (Vale.Transformers.InstructionRe... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_purge_empty_code",
"lemma_purge_empty_codes",
"lemma_purge_empty_while"
] | [
"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.Transformers.InstructionReorder.is_empty_code",
"Vale.Transformers.InstructionReorder.lemma_purge_empty_... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_purge_empty_codes (cs: codes) (fuel: nat) (s: machine_state)
: Lemma
(ensures (machine_eval_codes cs fuel s == machine_eval_codes (purge_empty_codes cs) fuel s))
(decreases %[fuel;cs]) =
| match cs with
| [] -> ()
| x :: xs ->
if is_empty_code x
then
(lemma_is_empty_code x fuel s;
lemma_purge_empty_codes xs fuel s)
else
(lemma_purge_empty_code x fuel s;
match machine_eval_code x fuel s with
| None -> ()
| Some s' -> lemma_purge_empty_codes xs fuel s') | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_sigver512 | val test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_sigver512 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.re... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 196,
"start_col": 0,
"start_line": 165
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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... | false | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_E... | [] | false | true | false | false | false | let test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64... | false |
Vale.Transformers.InstructionReorder.fst | Vale.Transformers.InstructionReorder.lemma_eval_while_equiv_states | val lemma_eval_while_equiv_states (cond: ocmp) (body: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(equiv_ostates (machine_eval_while cond body fuel s1) (machine_eval_while cond body fuel s2)
))
(decreases %[fuel;body]) | val lemma_eval_while_equiv_states (cond: ocmp) (body: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(equiv_ostates (machine_eval_while cond body fuel s1) (machine_eval_while cond body fuel s2)
))
(decreases %[fuel;body]) | let rec lemma_eval_code_equiv_states (c : code) (fuel:nat) (s1 s2 : machine_state) :
Lemma
(requires (equiv_states s1 s2))
(ensures (
let s1'', s2'' =
machine_eval_code c fuel s1,
machine_eval_code c fuel s2 in
equiv_ostates s1'' s2''))
(decreases %[fuel; c]) =
match ... | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.InstructionReorder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 504,
"start_col": 0,
"start_line": 423
} | (**
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... | {
"checked_file": "/",
"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_Code_s.fst.checked",
"Vale.Transformers.Lo... | [
{
"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
},
... | {
"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... | false |
cond: Vale.X64.Machine_Semantics_s.ocmp ->
body: Vale.X64.Machine_Semantics_s.code ->
fuel: Prims.nat ->
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)
... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_eval_code_equiv_states",
"lemma_eval_codes_equiv_states",
"lemma_eval_while_equiv_states"
] | [
"Vale.X64.Machine_Semantics_s.ocmp",
"Vale.X64.Machine_Semantics_s.code",
"Prims.nat",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Negation",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.Transformers.Instruct... | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_eval_while_equiv_states (cond: ocmp) (body: code) (fuel: nat) (s1 s2: machine_state)
: Lemma (requires (equiv_states s1 s2))
(ensures
(equiv_ostates (machine_eval_while cond body fuel s1) (machine_eval_while cond body fuel s2)
))
(decreases %[fuel;body]) =
| if fuel = 0
then ()
else
(reveal_opaque (`%valid_ocmp_opaque) valid_ocmp_opaque;
reveal_opaque (`%eval_ocmp_opaque) eval_ocmp_opaque;
let s1, b1 = machine_eval_ocmp s1 cond in
let s2, b2 = machine_eval_ocmp s2 cond in
assert (equiv_states s1 s2);
assert (b1 == b2);
if not b1
then ()
el... | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.check_bound | val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.... | val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.... | let check_bound b =
let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@inline_let]
let q1 = normalize_term (order % pow2 64) in
[@inline_let]
let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@inline_let]
let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@in... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 262,
"start_col": 0,
"start_line": 212
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"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... | false | b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.op_AmpAmp",
"Prims.op_Negation",
"Prims.bool",
"Prims.op_Equality",
"FStar.UInt64.t",
"Prims.l_or",
"Prims.b2t",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U64",
"FStar.UInt.size",
"FStar.UInt64.n",
"L... | [] | false | true | false | false | false | let check_bound b =
| let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@@ inline_let ]let q1 = normalize_term (order % pow2 64) in
[@@ inline_let ]let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@@ inline_let ]let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@@ inline_let ]let q4 = normalize_term... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.