effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val ins_VPaddd : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPaddd | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2]) | val ins_VPaddd : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPaddd
let ins_VPaddd = | false | null | false | make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPaddd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPaddd : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPaddd | [] | Vale.X64.Instructions_s.ins_VPaddd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_VPaddd | {
"end_col": 96,
"end_line": 68,
"start_col": 17,
"start_line": 68
} |
Prims.Tot | val ins_VPxor : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPxor | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2]) | val ins_VPxor : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPxor
let ins_VPxor = | false | null | false | make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPxor",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPxor : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPxor | [] | Vale.X64.Instructions_s.ins_VPxor | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_VPxor | {
"end_col": 94,
"end_line": 63,
"start_col": 16,
"start_line": 63
} |
Prims.Tot | val ins_Cpuid :
instr_dep
[inOut (one64Reg rRax); out (one64Reg rRbx); inOut (one64Reg rRcx); out (one64Reg rRdx)]
[] PreserveFlags eval_Cpuid | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Cpuid = make_ins (print "cpuid" []) | val ins_Cpuid :
instr_dep
[inOut (one64Reg rRax); out (one64Reg rRbx); inOut (one64Reg rRcx); out (one64Reg rRdx)]
[] PreserveFlags eval_Cpuid
let ins_Cpuid = | false | null | false | make_ins (print "cpuid" []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.one64Reg",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Instruction_s.out",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdx",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Cpuid",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Cpuid :
instr_dep
[inOut (one64Reg rRax); out (one64Reg rRbx); inOut (one64Reg rRcx); out (one64Reg rRdx)]
[] PreserveFlags eval_Cpuid | [] | Vale.X64.Instructions_s.ins_Cpuid | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRax);
Vale.X64.Instruction_s.out (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRbx);
Vale.X64.Instruction_s.inOut (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRcx);
Vale.X64.Instruction_s.out (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRdx)
]
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Cpuid | {
"end_col": 43,
"end_line": 55,
"start_col": 16,
"start_line": 55
} |
Prims.Tot | val ins_Pand : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pand | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src]) | val ins_Pand : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pand
let ins_Pand = | false | null | false | make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pand",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pand : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pand | [] | Vale.X64.Instructions_s.ins_Pand | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Pand | {
"end_col": 74,
"end_line": 65,
"start_col": 15,
"start_line": 65
} |
Prims.Tot | val ins_Xgetbv :
instr_dep
[out (one64Reg rRax); out (one64Reg rRdx)]
[one64Reg rRcx] PreserveFlags eval_Xgetbv | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Xgetbv = make_ins (print "xgetbv" []) | val ins_Xgetbv :
instr_dep
[out (one64Reg rRax); out (one64Reg rRdx)]
[one64Reg rRcx] PreserveFlags eval_Xgetbv
let ins_Xgetbv = | false | null | false | make_ins (print "xgetbv" []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.one64Reg",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Machine_s.rRdx",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Xgetbv",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Xgetbv :
instr_dep
[out (one64Reg rRax); out (one64Reg rRdx)]
[one64Reg rRcx] PreserveFlags eval_Xgetbv | [] | Vale.X64.Instructions_s.ins_Xgetbv | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.out (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRax);
Vale.X64.Instruction_s.out (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRdx)
]
[Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRcx]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Xgetbv | {
"end_col": 45,
"end_line": 57,
"start_col": 17,
"start_line": 57
} |
Prims.Tot | val ins_Pslld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Pslld amt) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt]) | val ins_Pslld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Pslld amt)
let ins_Pslld amt = | false | null | false | make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pslld",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pslld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Pslld amt) | [] | Vale.X64.Instructions_s.ins_Pslld | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | amt: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pslld amt) | {
"end_col": 76,
"end_line": 70,
"start_col": 20,
"start_line": 70
} |
Prims.Tot | val ins_Movdqu : instr_dep [out opXmm] [opXmm] PreserveFlags eval_Movdqu | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src]) | val ins_Movdqu : instr_dep [out opXmm] [opXmm] PreserveFlags eval_Movdqu
let ins_Movdqu = | false | null | false | make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Movdqu",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Movdqu : instr_dep [out opXmm] [opXmm] PreserveFlags eval_Movdqu | [] | Vale.X64.Instructions_s.ins_Movdqu | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Movdqu | {
"end_col": 78,
"end_line": 59,
"start_col": 17,
"start_line": 59
} |
Prims.Tot | val ins_Bswap64 : instr_dep [inOut op64] [] PreserveFlags eval_Bswap64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst]) | val ins_Bswap64 : instr_dep [inOut op64] [] PreserveFlags eval_Bswap64
let ins_Bswap64 = | false | null | false | make_ins (fun dst -> print_s "bswap" [P64 dst]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Bswap64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Bswap64 : instr_dep [inOut op64] [] PreserveFlags eval_Bswap64 | [] | Vale.X64.Instructions_s.ins_Bswap64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Bswap64 | {
"end_col": 65,
"end_line": 9,
"start_col": 18,
"start_line": 9
} |
Prims.Tot | val ins_VPalignr (amount:nat8) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPalignr amount) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount]) | val ins_VPalignr (amount:nat8) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPalignr amount)
let ins_VPalignr amount = | false | null | false | make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPalignr",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPalignr (amount:nat8) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPalignr amount) | [] | Vale.X64.Instructions_s.ins_VPalignr | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | amount: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_VPalignr amount) | {
"end_col": 96,
"end_line": 79,
"start_col": 2,
"start_line": 79
} |
Prims.Tot | val ins_And64 : instr_dep [inOut op64] [op64] HavocFlags eval_And64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src]) | val ins_And64 : instr_dep [inOut op64] [op64] HavocFlags eval_And64
let ins_And64 = | false | null | false | make_ins (fun dst src -> print_s "and" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_And64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_And64 : instr_dep [inOut op64] [op64] HavocFlags eval_And64 | [] | Vale.X64.Instructions_s.ins_And64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_And64 | {
"end_col": 74,
"end_line": 45,
"start_col": 16,
"start_line": 45
} |
Prims.Tot | val ins_Sub64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Sub64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src]) | val ins_Sub64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Sub64
let ins_Sub64 = | false | null | false | make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Sub64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Sub64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Sub64 | [] | Vale.X64.Instructions_s.ins_Sub64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Sub64 | {
"end_col": 74,
"end_line": 34,
"start_col": 16,
"start_line": 34
} |
Prims.Tot | val ins_Psrldq (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrldq amt) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt]) | val ins_Psrldq (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrldq amt)
let ins_Psrldq amt = | false | null | false | make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Psrldq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Psrldq (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrldq amt) | [] | Vale.X64.Instructions_s.ins_Psrldq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | amt: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Psrldq amt) | {
"end_col": 78,
"end_line": 74,
"start_col": 21,
"start_line": 74
} |
Prims.Tot | val ins_Paddd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Paddd | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src]) | val ins_Paddd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Paddd
let ins_Paddd = | false | null | false | make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Paddd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Paddd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Paddd | [] | Vale.X64.Instructions_s.ins_Paddd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Paddd | {
"end_col": 76,
"end_line": 67,
"start_col": 16,
"start_line": 67
} |
Prims.Tot | val ins_Mulx64 : instr_dep [out op64; out op64] [one64Reg rRdx; op64] PreserveFlags eval_Mulx64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src]) | val ins_Mulx64 : instr_dep [out op64; out op64] [one64Reg rRdx; op64] PreserveFlags eval_Mulx64
let ins_Mulx64 = | false | null | false | make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.one64Reg",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Mulx64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Mulx64 : instr_dep [out op64; out op64] [one64Reg rRdx; op64] PreserveFlags eval_Mulx64 | [] | Vale.X64.Instructions_s.ins_Mulx64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64;
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRdx; Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Mulx64 | {
"end_col": 86,
"end_line": 41,
"start_col": 2,
"start_line": 41
} |
Prims.Tot | val ins_VShufpd (permutation:int) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VShufpd permutation) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation]) | val ins_VShufpd (permutation:int) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VShufpd permutation)
let ins_VShufpd permutation = | false | null | false | make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VShufpd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VShufpd (permutation:int) :
instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VShufpd permutation) | [] | Vale.X64.Instructions_s.ins_VShufpd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | permutation: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_VShufpd permutation) | {
"end_col": 100,
"end_line": 84,
"start_col": 2,
"start_line": 84
} |
Prims.Tot | val ins_Pinsrd (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrd index) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index]) | val ins_Pinsrd (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrd index)
let ins_Pinsrd index = | false | null | false | make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pinsrd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.P32",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pinsrd (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrd index) | [] | Vale.X64.Instructions_s.ins_Pinsrd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | index: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pinsrd index) | {
"end_col": 95,
"end_line": 96,
"start_col": 23,
"start_line": 96
} |
Prims.Tot | val ins_Psrld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrld amt) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt]) | val ins_Psrld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrld amt)
let ins_Psrld amt = | false | null | false | make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Psrld",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Psrld (amt:int) : instr_dep [inOut opXmm] [] PreserveFlags (eval_Psrld amt) | [] | Vale.X64.Instructions_s.ins_Psrld | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | amt: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Psrld amt) | {
"end_col": 76,
"end_line": 72,
"start_col": 20,
"start_line": 72
} |
Prims.Tot | val ins_Pclmulqdq (imm:int) : instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Pclmulqdq imm) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm]) | val ins_Pclmulqdq (imm:int) : instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Pclmulqdq imm)
let ins_Pclmulqdq imm = | false | null | false | make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pclmulqdq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pclmulqdq (imm:int) : instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Pclmulqdq imm) | [] | Vale.X64.Instructions_s.ins_Pclmulqdq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | imm: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pclmulqdq imm) | {
"end_col": 98,
"end_line": 104,
"start_col": 24,
"start_line": 104
} |
Prims.Tot | val ins_LargeComment (_:string) : instr_dep [] [] PreserveFlags eval_LargeComment | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_LargeComment s = make_ins (print (";# " ^ s) []) | val ins_LargeComment (_:string) : instr_dep [] [] PreserveFlags eval_LargeComment
let ins_LargeComment s = | false | null | false | make_ins (print (";# " ^ s) []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.string",
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_LargeComment",
"Vale.X64.Instruction_s.print",
"Prims.op_Hat",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src])
let ins_Ghost = make_ins (print "" [])
let ins_Comment s = make_ins (print (";# " ^ s) [])
(* XXX[jb]: This syntax is a valid line comment in both GCC and
MASM. Unfortunately, `;` is not a valid line comment
starter in GCC (it is a statement separator), and `#` is
not a valid line comment starter in MASM. Fortunately
though, a semicolon on a line by itself is valid in GCC,
which means that we can place the MASM comment character,
followed by the GCC comment character, and get a valid
comment line on both. A cleaner approach, of course, would
be selectively choose the correct comment
character. However, that would require a larger scale
change to the code. *) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_LargeComment (_:string) : instr_dep [] [] PreserveFlags eval_LargeComment | [] | Vale.X64.Instructions_s.ins_LargeComment | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Prims.string
-> Vale.X64.Instruction_s.instr_dep []
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_LargeComment | {
"end_col": 56,
"end_line": 147,
"start_col": 25,
"start_line": 147
} |
Prims.Tot | val ins_Shufpd (permutation:int) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Shufpd permutation) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation]) | val ins_Shufpd (permutation:int) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Shufpd permutation)
let ins_Shufpd permutation = | false | null | false | make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Shufpd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Shufpd (permutation:int) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Shufpd permutation) | [] | Vale.X64.Instructions_s.ins_Shufpd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | permutation: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Shufpd permutation) | {
"end_col": 81,
"end_line": 82,
"start_col": 2,
"start_line": 82
} |
Prims.Tot | val ins_Pextrq (index:nat8) : instr_dep [out op64] [opXmm] PreserveFlags (eval_Pextrq index) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index]) | val ins_Pextrq (index:nat8) : instr_dep [out op64] [opXmm] PreserveFlags (eval_Pextrq index)
let ins_Pextrq index = | false | null | false | make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.opXmm",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pextrq",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pextrq (index:nat8) : instr_dep [out op64] [opXmm] PreserveFlags (eval_Pextrq index) | [] | Vale.X64.Instructions_s.ins_Pextrq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | index: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pextrq index) | {
"end_col": 95,
"end_line": 94,
"start_col": 23,
"start_line": 94
} |
Prims.Tot | val ins_SHA256_msg2 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg2 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src]) | val ins_SHA256_msg2 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg2
let ins_SHA256_msg2 = | false | null | false | make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_SHA256_msg2",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_SHA256_msg2 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg2 | [] | Vale.X64.Instructions_s.ins_SHA256_msg2 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_SHA256_msg2 | {
"end_col": 87,
"end_line": 130,
"start_col": 22,
"start_line": 130
} |
Prims.Tot | val ins_Pshufb : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pshufb | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src]) | val ins_Pshufb : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pshufb
let ins_Pshufb = | false | null | false | make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pshufb",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pshufb : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pshufb | [] | Vale.X64.Instructions_s.ins_Pshufb | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Pshufb | {
"end_col": 78,
"end_line": 86,
"start_col": 17,
"start_line": 86
} |
Prims.Tot | val ins_AESNI_keygen_assist (imm:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_AESNI_keygen_assist imm) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm]) | val ins_AESNI_keygen_assist (imm:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_AESNI_keygen_assist imm)
let ins_AESNI_keygen_assist imm = | false | null | false | make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_keygen_assist",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_keygen_assist (imm:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_AESNI_keygen_assist imm) | [] | Vale.X64.Instructions_s.ins_AESNI_keygen_assist | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | imm: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_AESNI_keygen_assist imm) | {
"end_col": 82,
"end_line": 123,
"start_col": 2,
"start_line": 123
} |
Prims.Tot | val ins_Pinsrq (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrq index) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index]) | val ins_Pinsrq (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrq index)
let ins_Pinsrq index = | false | null | false | make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pinsrq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pinsrq (index:nat8) : instr_dep [inOut opXmm] [op64] PreserveFlags (eval_Pinsrq index) | [] | Vale.X64.Instructions_s.ins_Pinsrq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | index: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pinsrq index) | {
"end_col": 95,
"end_line": 98,
"start_col": 23,
"start_line": 98
} |
Prims.Tot | val ins_Comment (_:string) : instr_dep [] [] PreserveFlags eval_Comment | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Comment s = make_ins (print (";# " ^ s) []) | val ins_Comment (_:string) : instr_dep [] [] PreserveFlags eval_Comment
let ins_Comment s = | false | null | false | make_ins (print (";# " ^ s) []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.string",
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Comment",
"Vale.X64.Instruction_s.print",
"Prims.op_Hat",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src])
let ins_Ghost = make_ins (print "" []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Comment (_:string) : instr_dep [] [] PreserveFlags eval_Comment | [] | Vale.X64.Instructions_s.ins_Comment | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Prims.string
-> Vale.X64.Instruction_s.instr_dep []
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Comment | {
"end_col": 51,
"end_line": 134,
"start_col": 20,
"start_line": 134
} |
Prims.Tot | val ins_AESNI_enc : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src]) | val ins_AESNI_enc : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc
let ins_AESNI_enc = | false | null | false | make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_enc",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_enc : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc | [] | Vale.X64.Instructions_s.ins_AESNI_enc | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AESNI_enc | {
"end_col": 81,
"end_line": 108,
"start_col": 20,
"start_line": 108
} |
Prims.Tot | val ins_Pshufd (permutation:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_Pshufd permutation) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation]) | val ins_Pshufd (permutation:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_Pshufd permutation)
let ins_Pshufd permutation = | false | null | false | make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pshufd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pshufd (permutation:nat8) :
instr_dep [out opXmm] [opXmm] PreserveFlags (eval_Pshufd permutation) | [] | Vale.X64.Instructions_s.ins_Pshufd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | permutation: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Pshufd permutation) | {
"end_col": 81,
"end_line": 90,
"start_col": 2,
"start_line": 90
} |
Prims.Tot | val ins_Pcmpeqd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pcmpeqd | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src]) | val ins_Pcmpeqd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pcmpeqd
let ins_Pcmpeqd = | false | null | false | make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pcmpeqd",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pcmpeqd : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pcmpeqd | [] | Vale.X64.Instructions_s.ins_Pcmpeqd | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Pcmpeqd | {
"end_col": 80,
"end_line": 92,
"start_col": 18,
"start_line": 92
} |
Prims.Tot | val ins_SHA256_msg1 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg1 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src]) | val ins_SHA256_msg1 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg1
let ins_SHA256_msg1 = | false | null | false | make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_SHA256_msg1",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_SHA256_msg1 : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_SHA256_msg1 | [] | Vale.X64.Instructions_s.ins_SHA256_msg1 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_SHA256_msg1 | {
"end_col": 87,
"end_line": 128,
"start_col": 22,
"start_line": 128
} |
Prims.Tot | val ins_Newline : instr_dep [] [] PreserveFlags eval_Newline | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Newline = make_ins (print "" []) | val ins_Newline : instr_dep [] [] PreserveFlags eval_Newline
let ins_Newline = | false | null | false | make_ins (print "" []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Newline",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src])
let ins_Ghost = make_ins (print "" [])
let ins_Comment s = make_ins (print (";# " ^ s) [])
(* XXX[jb]: This syntax is a valid line comment in both GCC and
MASM. Unfortunately, `;` is not a valid line comment
starter in GCC (it is a statement separator), and `#` is
not a valid line comment starter in MASM. Fortunately
though, a semicolon on a line by itself is valid in GCC,
which means that we can place the MASM comment character,
followed by the GCC comment character, and get a valid
comment line on both. A cleaner approach, of course, would
be selectively choose the correct comment
character. However, that would require a larger scale
change to the code. *)
let ins_LargeComment s = make_ins (print (";# " ^ s) []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Newline : instr_dep [] [] PreserveFlags eval_Newline | [] | Vale.X64.Instructions_s.ins_Newline | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep []
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Newline | {
"end_col": 40,
"end_line": 149,
"start_col": 18,
"start_line": 149
} |
Prims.Tot | val ins_VPclmulqdq (imm:int) : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPclmulqdq imm) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm]) | val ins_VPclmulqdq (imm:int) : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPclmulqdq imm)
let ins_VPclmulqdq imm = | false | null | false | make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPclmulqdq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPclmulqdq (imm:int) : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags (eval_VPclmulqdq imm) | [] | Vale.X64.Instructions_s.ins_VPclmulqdq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | imm: Prims.int
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_VPclmulqdq imm) | {
"end_col": 95,
"end_line": 106,
"start_col": 2,
"start_line": 106
} |
Prims.Tot | val ins_VPslldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPslldq count) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count]) | val ins_VPslldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPslldq count)
let ins_VPslldq count = | false | null | false | make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPslldq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPslldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPslldq count) | [] | Vale.X64.Instructions_s.ins_VPslldq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | count: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_VPslldq count) | {
"end_col": 98,
"end_line": 100,
"start_col": 24,
"start_line": 100
} |
Prims.Tot | val ins_Ghost : instr_dep [] [] PreserveFlags eval_Ghost | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Ghost = make_ins (print "" []) | val ins_Ghost : instr_dep [] [] PreserveFlags eval_Ghost
let ins_Ghost = | false | null | false | make_ins (print "" []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Ghost",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Ghost : instr_dep [] [] PreserveFlags eval_Ghost | [] | Vale.X64.Instructions_s.ins_Ghost | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep []
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Ghost | {
"end_col": 38,
"end_line": 132,
"start_col": 16,
"start_line": 132
} |
Prims.Tot | val ins_VAESNI_enc_last : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc_last | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2]) | val ins_VAESNI_enc_last : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc_last
let ins_VAESNI_enc_last = | false | null | false | make_ins (fun dst src1 src2 -> print "vaesenclast" [PXmm dst; PXmm src1; PXmm src2]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VAESNI_enc_last",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VAESNI_enc_last : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc_last | [] | Vale.X64.Instructions_s.ins_VAESNI_enc_last | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_VAESNI_enc_last | {
"end_col": 85,
"end_line": 114,
"start_col": 2,
"start_line": 114
} |
Prims.Tot | val ins_VAESNI_enc : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2]) | val ins_VAESNI_enc : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc
let ins_VAESNI_enc = | false | null | false | make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VAESNI_enc",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VAESNI_enc : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VAESNI_enc | [] | Vale.X64.Instructions_s.ins_VAESNI_enc | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_VAESNI_enc | {
"end_col": 82,
"end_line": 110,
"start_col": 2,
"start_line": 110
} |
Prims.Tot | val ins_AESNI_dec_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec_last | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src]) | val ins_AESNI_dec_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec_last
let ins_AESNI_dec_last = | false | null | false | make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_dec_last",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_dec_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec_last | [] | Vale.X64.Instructions_s.ins_AESNI_dec_last | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AESNI_dec_last | {
"end_col": 90,
"end_line": 118,
"start_col": 25,
"start_line": 118
} |
Prims.Tot | val ins_AESNI_dec : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src]) | val ins_AESNI_dec : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec
let ins_AESNI_dec = | false | null | false | make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_dec",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_dec : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_dec | [] | Vale.X64.Instructions_s.ins_AESNI_dec | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AESNI_dec | {
"end_col": 81,
"end_line": 116,
"start_col": 20,
"start_line": 116
} |
Prims.Tot | val ins_Add64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Add64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src]) | val ins_Add64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Add64
let ins_Add64 = | false | null | false | make_ins (fun dst src -> print_s "add" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Add64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Add64 : instr_dep [out opFlagsCf; inOut op64] [op64] HavocFlags eval_Add64 | [] | Vale.X64.Instructions_s.ins_Add64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Add64 | {
"end_col": 74,
"end_line": 13,
"start_col": 16,
"start_line": 13
} |
Prims.Tot | val ins_Shl64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shl64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt]) | val ins_Shl64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shl64
let ins_Shl64 = | false | null | false | make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Shl64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.PShift",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Shl64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shl64 | [] | Vale.X64.Instructions_s.ins_Shl64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Shl64 | {
"end_col": 77,
"end_line": 53,
"start_col": 16,
"start_line": 53
} |
Prims.Tot | val ins_Pxor : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pxor | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src]) | val ins_Pxor : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pxor
let ins_Pxor = | false | null | false | make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Pxor",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Pxor : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_Pxor | [] | Vale.X64.Instructions_s.ins_Pxor | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Pxor | {
"end_col": 74,
"end_line": 61,
"start_col": 15,
"start_line": 61
} |
Prims.Tot | val ins_Palignr (amount:nat8) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Palignr amount) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount]) | val ins_Palignr (amount:nat8) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Palignr amount)
let ins_Palignr amount = | false | null | false | make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Palignr",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Palignr (amount:nat8) :
instr_dep [inOut opXmm] [opXmm] PreserveFlags (eval_Palignr amount) | [] | Vale.X64.Instructions_s.ins_Palignr | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | amount: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_Palignr amount) | {
"end_col": 77,
"end_line": 77,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val ins_AESNI_imc : instr_dep [out opXmm] [opXmm] PreserveFlags eval_AESNI_imc | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src]) | val ins_AESNI_imc : instr_dep [out opXmm] [opXmm] PreserveFlags eval_AESNI_imc
let ins_AESNI_imc = | false | null | false | make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_imc",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_imc : instr_dep [out opXmm] [opXmm] PreserveFlags eval_AESNI_imc | [] | Vale.X64.Instructions_s.ins_AESNI_imc | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AESNI_imc | {
"end_col": 81,
"end_line": 120,
"start_col": 20,
"start_line": 120
} |
Prims.Tot | val ins_AESNI_enc_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc_last | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src]) | val ins_AESNI_enc_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc_last
let ins_AESNI_enc_last = | false | null | false | make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AESNI_enc_last",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AESNI_enc_last : instr_dep [inOut opXmm] [opXmm] PreserveFlags eval_AESNI_enc_last | [] | Vale.X64.Instructions_s.ins_AESNI_enc_last | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AESNI_enc_last | {
"end_col": 90,
"end_line": 112,
"start_col": 25,
"start_line": 112
} |
Prims.Tot | val ins_VPsrldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPsrldq count) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count]) | val ins_VPsrldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPsrldq count)
let ins_VPsrldq count = | false | null | false | make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat8",
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPsrldq",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.PImm",
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPsrldq (count:nat8) : instr_dep [out opXmm] [opXmm] PreserveFlags (eval_VPsrldq count) | [] | Vale.X64.Instructions_s.ins_VPsrldq | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | count: Vale.Def.Types_s.nat8
-> Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
(Vale.X64.Instructions_s.eval_VPsrldq count) | {
"end_col": 98,
"end_line": 102,
"start_col": 24,
"start_line": 102
} |
Prims.Tot | val ins_VPshufb : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPshufb | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2]) | val ins_VPshufb : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPshufb
let ins_VPshufb = | false | null | false | make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_VPshufb",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_VPshufb : instr_dep [out opXmm] [opXmm; opXmm] PreserveFlags eval_VPshufb | [] | Vale.X64.Instructions_s.ins_VPshufb | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.opXmm]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_VPshufb | {
"end_col": 98,
"end_line": 87,
"start_col": 18,
"start_line": 87
} |
Prims.Tot | val ins_Space (_:nat) : instr_dep [] [] PreserveFlags eval_Space | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Space n = make_ins (print "" []) | val ins_Space (_:nat) : instr_dep [] [] PreserveFlags eval_Space
let ins_Space n = | false | null | false | make_ins (print "" []) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Space",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.instr_dep"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src])
let ins_Ghost = make_ins (print "" [])
let ins_Comment s = make_ins (print (";# " ^ s) [])
(* XXX[jb]: This syntax is a valid line comment in both GCC and
MASM. Unfortunately, `;` is not a valid line comment
starter in GCC (it is a statement separator), and `#` is
not a valid line comment starter in MASM. Fortunately
though, a semicolon on a line by itself is valid in GCC,
which means that we can place the MASM comment character,
followed by the GCC comment character, and get a valid
comment line on both. A cleaner approach, of course, would
be selectively choose the correct comment
character. However, that would require a larger scale
change to the code. *)
let ins_LargeComment s = make_ins (print (";# " ^ s) [])
let ins_Newline = make_ins (print "" []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Space (_:nat) : instr_dep [] [] PreserveFlags eval_Space | [] | Vale.X64.Instructions_s.ins_Space | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.nat
-> Vale.X64.Instruction_s.instr_dep []
[]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Space | {
"end_col": 40,
"end_line": 151,
"start_col": 18,
"start_line": 151
} |
Prims.Tot | val ins_Prefetchnta : instr_dep [] [op64] PreserveFlags eval_Prefetchnta | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Prefetchnta = make_ins (fun loc -> print_s "prefetchnta" [P64 loc]) | val ins_Prefetchnta : instr_dep [] [op64] PreserveFlags eval_Prefetchnta
let ins_Prefetchnta = | false | null | false | make_ins (fun loc -> print_s "prefetchnta" [P64 loc]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Prefetchnta",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm])
let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src])
let ins_SHA256_msg1 = make_ins (fun dst src -> print "sha256msg1" [PXmm dst; PXmm src])
let ins_SHA256_msg2 = make_ins (fun dst src -> print "sha256msg2" [PXmm dst; PXmm src])
let ins_Ghost = make_ins (print "" [])
let ins_Comment s = make_ins (print (";# " ^ s) [])
(* XXX[jb]: This syntax is a valid line comment in both GCC and
MASM. Unfortunately, `;` is not a valid line comment
starter in GCC (it is a statement separator), and `#` is
not a valid line comment starter in MASM. Fortunately
though, a semicolon on a line by itself is valid in GCC,
which means that we can place the MASM comment character,
followed by the GCC comment character, and get a valid
comment line on both. A cleaner approach, of course, would
be selectively choose the correct comment
character. However, that would require a larger scale
change to the code. *)
let ins_LargeComment s = make_ins (print (";# " ^ s) [])
let ins_Newline = make_ins (print "" [])
let ins_Space n = make_ins (print "" []) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Prefetchnta : instr_dep [] [op64] PreserveFlags eval_Prefetchnta | [] | Vale.X64.Instructions_s.ins_Prefetchnta | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep []
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Prefetchnta | {
"end_col": 75,
"end_line": 153,
"start_col": 22,
"start_line": 153
} |
Prims.Tot | val ins_AddLea64 :instr_dep [out op64] [op64; op64] PreserveFlags eval_AddLea64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)]) | val ins_AddLea64 :instr_dep [out op64] [op64; op64] PreserveFlags eval_AddLea64
let ins_AddLea64 = | false | null | false | make_ins (fun (dst: operand64) (src1: operand64) (src2: operand64) ->
let m =
match (src1, src2) with
| OReg r1, OConst i2 -> MReg (Reg 0 r1) i2
| OReg r1, OReg r2 -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128
in
let m = (m, Public) in
print "lea" [P64 dst; P64 (OMem m)]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_AddLea64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Machine_s.OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Arch.HeapTypes_s.Public",
"Vale.X64.Machine_s.operand",
"Vale.X64.Machine_s.MReg",
"Vale.X64.Machine_s.Reg",
"Vale.X64.Machine_s.MIndex",
"Vale.X64.Machine_s.MConst",
"Vale.X64.Machine_s.pow2_128",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AddLea64 :instr_dep [out op64] [op64; op64] PreserveFlags eval_AddLea64 | [] | Vale.X64.Instructions_s.ins_AddLea64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64; Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_AddLea64 | {
"end_col": 40,
"end_line": 26,
"start_col": 2,
"start_line": 16
} |
Prims.Tot | val ins_SHA256_rnds2 :
instr_dep [inOut opXmm] [opXmm; oneXmm (OReg 0)] PreserveFlags eval_SHA256_rnds2 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_SHA256_rnds2 =
make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src]) | val ins_SHA256_rnds2 :
instr_dep [inOut opXmm] [opXmm; oneXmm (OReg 0)] PreserveFlags eval_SHA256_rnds2
let ins_SHA256_rnds2 = | false | null | false | make_ins (fun dst src -> Print "sha256rnds2" PrintPSha256rnds2 [PXmm dst; PXmm src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.oneXmm",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_SHA256_rnds2",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Instruction_s.Print",
"Vale.X64.Instruction_s.PrintPSha256rnds2",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.PXmm",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src]))
let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt])
let ins_Shl64 = make_ins (fun dst amt -> print_s "shl" [P64 dst; PShift amt])
let ins_Cpuid = make_ins (print "cpuid" [])
let ins_Xgetbv = make_ins (print "xgetbv" [])
let ins_Movdqu = make_ins (fun dst src -> print "movdqu" [PXmm dst; PXmm src])
let ins_Pxor = make_ins (fun dst src -> print "pxor" [PXmm dst; PXmm src])
let ins_VPxor = make_ins (fun dst src1 src2 -> print "vpxor" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pand = make_ins (fun dst src -> print "pand" [PXmm dst; PXmm src])
let ins_Paddd = make_ins (fun dst src -> print "paddd" [PXmm dst; PXmm src])
let ins_VPaddd = make_ins (fun dst src1 src2 -> print "vpaddd" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pslld amt = make_ins (fun dst -> print "pslld" [PXmm dst; PImm amt])
let ins_Psrld amt = make_ins (fun dst -> print "psrld" [PXmm dst; PImm amt])
let ins_Psrldq amt = make_ins (fun dst -> print "psrldq" [PXmm dst; PImm amt])
let ins_Palignr amount =
make_ins (fun dst src -> print "palignr" [PXmm dst; PXmm src; PImm amount])
let ins_VPalignr amount =
make_ins (fun dst src1 src2 -> print "vpalignr" [PXmm dst; PXmm src1; PXmm src2; PImm amount])
let ins_Shufpd permutation =
make_ins (fun dst src -> print "shufpd" [PXmm dst; PXmm src; PImm permutation])
let ins_VShufpd permutation =
make_ins (fun dst src1 src2 -> print "vshufpd" [PXmm dst; PXmm src1; PXmm src2; PImm permutation])
let ins_Pshufb = make_ins (fun dst src -> print "pshufb" [PXmm dst; PXmm src])
let ins_VPshufb = make_ins (fun dst src1 src2 -> print "vpshufb" [PXmm dst; PXmm src1; PXmm src2])
let ins_Pshufd permutation =
make_ins (fun dst src -> print "pshufd" [PXmm dst; PXmm src; PImm permutation])
let ins_Pcmpeqd = make_ins (fun dst src -> print "pcmpeqd" [PXmm dst; PXmm src])
let ins_Pextrq index = make_ins (fun dst src -> print "pextrq" [P64 dst; PXmm src; PImm index])
let ins_Pinsrd index = make_ins (fun dst src -> print "pinsrd" [PXmm dst; P32 src; PImm index])
let ins_Pinsrq index = make_ins (fun dst src -> print "pinsrq" [PXmm dst; P64 src; PImm index])
let ins_VPslldq count = make_ins (fun dst src -> print "vpslldq" [PXmm dst; PXmm src; PImm count])
let ins_VPsrldq count = make_ins (fun dst src -> print "vpsrldq" [PXmm dst; PXmm src; PImm count])
let ins_Pclmulqdq imm = make_ins (fun dst src -> print "pclmulqdq" [PXmm dst; PXmm src; PImm imm])
let ins_VPclmulqdq imm =
make_ins (fun dst src1 src2 -> print "vpclmulqdq" [PXmm dst; PXmm src1; PXmm src2; PImm imm])
let ins_AESNI_enc = make_ins (fun dst src -> print "aesenc" [PXmm dst; PXmm src])
let ins_VAESNI_enc =
make_ins (fun dst src1 src2 -> print "vaesenc" [PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_enc_last = make_ins (fun dst src -> print "aesenclast" [PXmm dst; PXmm src])
let ins_VAESNI_enc_last =
make_ins (fun dst src1 src2 -> print "vaesenclast"[PXmm dst; PXmm src1; PXmm src2])
let ins_AESNI_dec = make_ins (fun dst src -> print "aesdec" [PXmm dst; PXmm src])
let ins_AESNI_dec_last = make_ins (fun dst src -> print "aesdeclast" [PXmm dst; PXmm src])
let ins_AESNI_imc = make_ins (fun dst src -> print "aesimc" [PXmm dst; PXmm src])
let ins_AESNI_keygen_assist imm =
make_ins (fun dst src -> print "aeskeygenassist" [PXmm dst; PXmm src; PImm imm]) | false | false | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_SHA256_rnds2 :
instr_dep [inOut opXmm] [opXmm; oneXmm (OReg 0)] PreserveFlags eval_SHA256_rnds2 | [] | Vale.X64.Instructions_s.ins_SHA256_rnds2 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opXmm]
[Vale.X64.Instruction_s.opXmm; Vale.X64.Instruction_s.oneXmm (Vale.X64.Machine_s.OReg 0)]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_SHA256_rnds2 | {
"end_col": 86,
"end_line": 126,
"start_col": 2,
"start_line": 126
} |
Prims.Tot | val ins_Xor64 : instr_dep [inOut op64; out opFlagsCf; out opFlagsOf] [op64] HavocFlags eval_Xor64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src])) | val ins_Xor64 : instr_dep [inOut op64; out opFlagsCf; out opFlagsOf] [op64] HavocFlags eval_Xor64
let ins_Xor64 = | false | null | false | make_ins (fun dst src ->
print_s "xor" (if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src])) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.opFlagsOf",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Xor64",
"Vale.X64.Machine_s.operand",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Prims.op_AmpAmp",
"Vale.X64.Machine_s.uu___is_OReg",
"Prims.op_Equality",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P32",
"Prims.bool",
"Vale.X64.Instruction_s.P64",
"Prims.list",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Xor64 : instr_dep [inOut op64; out opFlagsCf; out opFlagsOf] [op64] HavocFlags eval_Xor64 | [] | Vale.X64.Instructions_s.ins_Xor64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64;
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.out Vale.X64.Instruction_s.opFlagsOf
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Xor64 | {
"end_col": 78,
"end_line": 49,
"start_col": 16,
"start_line": 47
} |
Prims.Tot | val update_stack128_and_taint (ptr: int) (v: quad32) (s: machine_state) (t: taint) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
} | val update_stack128_and_taint (ptr: int) (v: quad32) (s: machine_state) (t: taint) : machine_state
let update_stack128_and_taint (ptr: int) (v: quad32) (s: machine_state) (t: taint) : machine_state = | false | null | false | let Machine_stack init_rsp mem = s.ms_stack in
{
s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
} | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.Def.Types_s.quad32",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Arch.HeapTypes_s.taint",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.update_stack128'",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.update_n",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.machine_stack"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
} | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_stack128_and_taint (ptr: int) (v: quad32) (s: machine_state) (t: taint) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_stack128_and_taint | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ptr: Prims.int ->
v: Vale.Def.Types_s.quad32 ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 3,
"end_line": 243,
"start_col": 96,
"start_line": 238
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let codes = BC.codes_t instr_annotation | let codes = | false | null | false | BC.codes_t instr_annotation | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Bytes_Code_s.codes_t",
"Vale.X64.Machine_Semantics_s.instr_annotation"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val codes : Type0 | [] | Vale.X64.Machine_Semantics_s.codes | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 39,
"end_line": 47,
"start_col": 12,
"start_line": 47
} |
|
Prims.Tot | val eval_reg_int (r: reg) (s: machine_state) : int | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s) | val eval_reg_int (r: reg) (s: machine_state) : int
let eval_reg_int (r: reg) (s: machine_state) : int = | false | null | false | t_reg_to_int r.rf (eval_reg r s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_s.t_reg_to_int",
"Vale.X64.Machine_s.__proj__Reg__item__rf",
"Vale.X64.Machine_Semantics_s.eval_reg",
"Prims.int"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_reg_int (r: reg) (s: machine_state) : int | [] | Vale.X64.Machine_Semantics_s.eval_reg_int | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg -> s: Vale.X64.Machine_Semantics_s.machine_state -> Prims.int | {
"end_col": 90,
"end_line": 82,
"start_col": 58,
"start_line": 82
} |
Prims.Tot | val equals_instr (x1 x2: instr_t_record) : Type0 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2) | val equals_instr (x1 x2: instr_t_record) : Type0
let equals_instr (x1 x2: instr_t_record) : Type0 = | false | null | false | squash (x1 == x2) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.instr_t_record",
"Prims.squash",
"Prims.eq2"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"] | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val equals_instr (x1 x2: instr_t_record) : Type0 | [] | Vale.X64.Machine_Semantics_s.equals_instr | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x1: Vale.X64.Instruction_s.instr_t_record -> x2: Vale.X64.Instruction_s.instr_t_record -> Type0 | {
"end_col": 19,
"end_line": 28,
"start_col": 2,
"start_line": 28
} |
Prims.Tot | val valid_dst_stack64 (rsp: nat64) (ptr: int) (st: machine_stack) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp | val valid_dst_stack64 (rsp: nat64) (ptr: int) (st: machine_stack) : bool
let valid_dst_stack64 (rsp: nat64) (ptr: int) (st: machine_stack) : bool = | false | null | false | let Machine_stack init_rsp mem = st in
ptr >= rsp && ptr + 8 <= init_rsp | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat64",
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_dst_stack64 (rsp: nat64) (ptr: int) (st: machine_stack) : bool | [] | Vale.X64.Machine_Semantics_s.valid_dst_stack64 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | rsp: Vale.Def.Types_s.nat64 -> ptr: Prims.int -> st: Vale.X64.Machine_Semantics_s.machine_stack
-> Prims.bool | {
"end_col": 35,
"end_line": 299,
"start_col": 71,
"start_line": 296
} |
Prims.Tot | val update_stack_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
} | val update_stack_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state
let update_stack_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state = | false | null | false | let Machine_stack init_rsp mem = s.ms_stack in
{
s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t
} | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Arch.HeapTypes_s.taint",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.update_stack64'",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.update_n",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.machine_stack"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_stack_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_stack_and_taint | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ptr: Prims.int ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 3,
"end_line": 236,
"start_col": 92,
"start_line": 231
} |
Prims.Tot | val eval_reg (r: reg) (s: machine_state) : t_reg r | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r | val eval_reg (r: reg) (s: machine_state) : t_reg r
let eval_reg (r: reg) (s: machine_state) : t_reg r = | false | null | false | s.ms_regs r | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_s.t_reg"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2 | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_reg (r: reg) (s: machine_state) : t_reg r | [] | Vale.X64.Machine_Semantics_s.eval_reg | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg -> s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_s.t_reg r | {
"end_col": 69,
"end_line": 78,
"start_col": 58,
"start_line": 78
} |
Prims.Tot | val eval_ocmp_opaque (s: machine_state) (c: ocmp) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c | val eval_ocmp_opaque (s: machine_state) (c: ocmp) : bool
let eval_ocmp_opaque (s: machine_state) (c: ocmp) : bool = | false | null | false | eval_ocmp s c | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.ocmp",
"Vale.X64.Machine_Semantics_s.eval_ocmp",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_ocmp_opaque (s: machine_state) (c: ocmp) : bool | [] | Vale.X64.Machine_Semantics_s.eval_ocmp_opaque | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.X64.Machine_Semantics_s.machine_state -> c: Vale.X64.Machine_Semantics_s.ocmp -> Prims.bool | {
"end_col": 70,
"end_line": 124,
"start_col": 57,
"start_line": 124
} |
Prims.Tot | val update_cf_of (new_cf new_of: bool) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_cf_of (new_cf new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' (update_of' s.ms_flags new_of) new_cf } ) | val update_cf_of (new_cf new_of: bool) : st unit
let update_cf_of (new_cf new_of: bool) : st unit = | false | null | false | let* s = get in
set ({ s with ms_flags = update_cf' (update_of' s.ms_flags new_of) new_cf }) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.update_cf'",
"Vale.X64.Machine_Semantics_s.update_of'",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s)
let update_reg_64 (r:reg_64) (v:nat64) : st unit =
let* s = get in
set (update_reg_64' r v s)
let update_reg_xmm (x:reg_xmm) (ins:ins) (v:quad32) : st unit =
let* s = get in
set ( { (update_reg_xmm' x v s) with ms_flags = havoc_flags } )
let update_xmm_preserve_flags (x:reg_xmm) (v:quad32) : st unit =
let* s = get in
set ( update_reg_xmm' x v s )
let update_flags (new_flags:flags_t) : st unit =
let* s = get in
set ( { s with ms_flags = new_flags } )
let update_cf (new_cf:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' s.ms_flags new_cf } )
let update_of (new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_of' s.ms_flags new_of } ) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_cf_of (new_cf new_of: bool) : st unit | [] | Vale.X64.Machine_Semantics_s.update_cf_of | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | new_cf: Prims.bool -> new_of: Prims.bool -> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 80,
"end_line": 471,
"start_col": 2,
"start_line": 470
} |
Prims.Tot | val eval_mem (ptr: int) (s: machine_state) : nat64 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap) | val eval_mem (ptr: int) (s: machine_state) : nat64
let eval_mem (ptr: int) (s: machine_state) : nat64 = | false | null | false | get_heap_val64 ptr (heap_get s.ms_heap) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Arch.MachineHeap_s.get_heap_val64",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.Def.Types_s.nat64"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_mem (ptr: int) (s: machine_state) : nat64 | [] | Vale.X64.Machine_Semantics_s.eval_mem | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.X64.Machine_Semantics_s.machine_state -> Vale.Def.Types_s.nat64 | {
"end_col": 97,
"end_line": 84,
"start_col": 58,
"start_line": 84
} |
Prims.Tot | val valid_ocmp_opaque (c: ocmp) (s: machine_state) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s | val valid_ocmp_opaque (c: ocmp) (s: machine_state) : bool
let valid_ocmp_opaque (c: ocmp) (s: machine_state) : bool = | false | null | false | valid_ocmp c s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.ocmp",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.valid_ocmp",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_ocmp_opaque (c: ocmp) (s: machine_state) : bool | [] | Vale.X64.Machine_Semantics_s.valid_ocmp_opaque | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c: Vale.X64.Machine_Semantics_s.ocmp -> s: Vale.X64.Machine_Semantics_s.machine_state -> Prims.bool | {
"end_col": 72,
"end_line": 293,
"start_col": 58,
"start_line": 293
} |
Prims.Tot | val valid_src_stack64 (ptr: int) (st: machine_stack) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem | val valid_src_stack64 (ptr: int) (st: machine_stack) : bool
let valid_src_stack64 (ptr: int) (st: machine_stack) : bool = | false | null | false | let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
} | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_src_stack64 (ptr: int) (st: machine_stack) : bool | [] | Vale.X64.Machine_Semantics_s.valid_src_stack64 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> st: Vale.X64.Machine_Semantics_s.machine_stack -> Prims.bool | {
"end_col": 22,
"end_line": 248,
"start_col": 59,
"start_line": 246
} |
Prims.Tot | val valid_dst_stack128 (rsp: nat64) (ptr: int) (st: machine_stack) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp | val valid_dst_stack128 (rsp: nat64) (ptr: int) (st: machine_stack) : bool
let valid_dst_stack128 (rsp: nat64) (ptr: int) (st: machine_stack) : bool = | false | null | false | let Machine_stack init_rsp mem = st in
ptr >= rsp && ptr + 16 <= init_rsp | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat64",
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_dst_stack128 (rsp: nat64) (ptr: int) (st: machine_stack) : bool | [] | Vale.X64.Machine_Semantics_s.valid_dst_stack128 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | rsp: Vale.Def.Types_s.nat64 -> ptr: Prims.int -> st: Vale.X64.Machine_Semantics_s.machine_stack
-> Prims.bool | {
"end_col": 38,
"end_line": 305,
"start_col": 72,
"start_line": 302
} |
Prims.Tot | val check_imm (valid: bool) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail | val check_imm (valid: bool) : st unit
let check_imm (valid: bool) : st unit = | false | null | false | if valid then return () else fail | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Machine_Semantics_s.return",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.fail",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_imm (valid: bool) : st unit | [] | Vale.X64.Machine_Semantics_s.check_imm | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | valid: Prims.bool -> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 8,
"end_line": 408,
"start_col": 2,
"start_line": 405
} |
Prims.Tot | val update_flags (new_flags: flags_t) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_flags (new_flags:flags_t) : st unit =
let* s = get in
set ( { s with ms_flags = new_flags } ) | val update_flags (new_flags: flags_t) : st unit
let update_flags (new_flags: flags_t) : st unit = | false | null | false | let* s = get in
set ({ s with ms_flags = new_flags }) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.flags_t",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s)
let update_reg_64 (r:reg_64) (v:nat64) : st unit =
let* s = get in
set (update_reg_64' r v s)
let update_reg_xmm (x:reg_xmm) (ins:ins) (v:quad32) : st unit =
let* s = get in
set ( { (update_reg_xmm' x v s) with ms_flags = havoc_flags } )
let update_xmm_preserve_flags (x:reg_xmm) (v:quad32) : st unit =
let* s = get in
set ( update_reg_xmm' x v s ) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_flags (new_flags: flags_t) : st unit | [] | Vale.X64.Machine_Semantics_s.update_flags | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | new_flags: Vale.X64.Machine_Semantics_s.flags_t -> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 41,
"end_line": 459,
"start_col": 2,
"start_line": 458
} |
Prims.Tot | val flags_none (f: flag) : flag_val_t | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let flags_none (f:flag) : flag_val_t = None | val flags_none (f: flag) : flag_val_t
let flags_none (f: flag) : flag_val_t = | false | null | false | None | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.flag",
"FStar.Pervasives.Native.None",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.flag_val_t"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val flags_none (f: flag) : flag_val_t | [] | Vale.X64.Machine_Semantics_s.flags_none | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Vale.X64.Machine_s.flag -> Vale.X64.Machine_Semantics_s.flag_val_t | {
"end_col": 43,
"end_line": 341,
"start_col": 39,
"start_line": 341
} |
Prims.Tot | val overflow (flags: flags_t) : flag_val_t | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let overflow(flags:flags_t) : flag_val_t =
flags fOverflow | val overflow (flags: flags_t) : flag_val_t
let overflow (flags: flags_t) : flag_val_t = | false | null | false | flags fOverflow | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.flags_t",
"Vale.X64.Machine_s.fOverflow",
"Vale.X64.Machine_Semantics_s.flag_val_t"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val overflow (flags: flags_t) : flag_val_t | [] | Vale.X64.Machine_Semantics_s.overflow | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | flags: Vale.X64.Machine_Semantics_s.flags_t -> Vale.X64.Machine_Semantics_s.flag_val_t | {
"end_col": 17,
"end_line": 360,
"start_col": 2,
"start_line": 360
} |
Prims.Tot | val get:st machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get : st machine_state =
fun s -> (s, s) | val get:st machine_state
let get:st machine_state = | false | null | false | fun s -> (s, s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get:st machine_state | [] | Vale.X64.Machine_Semantics_s.get | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Machine_Semantics_s.st Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 17,
"end_line": 393,
"start_col": 2,
"start_line": 393
} |
Prims.Tot | val update_operand64' (o: operand64) (ins: ins) (v: nat64) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags } | val update_operand64' (o: operand64) (ins: ins) (v: nat64) (s: machine_state) : machine_state
let update_operand64' (o: operand64) (ins: ins) (v: nat64) (s: machine_state) : machine_state = | false | null | false | { (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags } | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.havoc_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_operand64' (o: operand64) (ins: ins) (v: nat64) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_operand64' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
o: Vale.X64.Machine_s.operand64 ->
ins: Vale.X64.Machine_Semantics_s.ins ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 72,
"end_line": 346,
"start_col": 4,
"start_line": 346
} |
Prims.Tot | val update_operand64_preserve_flags (dst: operand64) (v: nat64) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s) | val update_operand64_preserve_flags (dst: operand64) (v: nat64) : st unit
let update_operand64_preserve_flags (dst: operand64) (v: nat64) : st unit = | false | null | false | let* _ = check (valid_dst_operand64 dst) in
let* s = get in
set (update_operand64_preserve_flags' dst v s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.check",
"Vale.X64.Machine_Semantics_s.valid_dst_operand64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags'",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_operand64_preserve_flags (dst: operand64) (v: nat64) : st unit | [] | Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst: Vale.X64.Machine_s.operand64 -> v: Vale.Def.Types_s.nat64
-> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 48,
"end_line": 435,
"start_col": 2,
"start_line": 433
} |
Prims.Tot | val update_operand64_preserve_flags' (o: operand64) (v: nat64) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s | val update_operand64_preserve_flags' (o: operand64) (v: nat64) (s: machine_state) : machine_state
let update_operand64_preserve_flags' (o: operand64) (v: nat64) (s: machine_state) : machine_state = | false | null | false | update_operand64_preserve_flags'' o v s s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags''"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_operand64_preserve_flags' (o: operand64) (v: nat64) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
o: Vale.X64.Machine_s.operand64 ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 43,
"end_line": 329,
"start_col": 2,
"start_line": 329
} |
Prims.Tot | val instr_apply_eval
(outs: list instr_out)
(args: list instr_operand)
(f: instr_eval_t outs args)
(oprs: instr_operands_t outs args)
(s: machine_state)
: option (instr_ret_t outs) | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let instr_apply_eval
(outs:list instr_out) (args:list instr_operand)
(f:instr_eval_t outs args) (oprs:instr_operands_t outs args) (s:machine_state)
: option (instr_ret_t outs) =
instr_apply_eval_inouts outs outs args f oprs s | val instr_apply_eval
(outs: list instr_out)
(args: list instr_operand)
(f: instr_eval_t outs args)
(oprs: instr_operands_t outs args)
(s: machine_state)
: option (instr_ret_t outs)
let instr_apply_eval
(outs: list instr_out)
(args: list instr_operand)
(f: instr_eval_t outs args)
(oprs: instr_operands_t outs args)
(s: machine_state)
: option (instr_ret_t outs) = | false | null | false | instr_apply_eval_inouts outs outs args f oprs s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.instr_eval_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.instr_apply_eval_inouts",
"FStar.Pervasives.Native.option",
"Vale.X64.Instruction_s.instr_ret_t"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s)
let update_reg_64 (r:reg_64) (v:nat64) : st unit =
let* s = get in
set (update_reg_64' r v s)
let update_reg_xmm (x:reg_xmm) (ins:ins) (v:quad32) : st unit =
let* s = get in
set ( { (update_reg_xmm' x v s) with ms_flags = havoc_flags } )
let update_xmm_preserve_flags (x:reg_xmm) (v:quad32) : st unit =
let* s = get in
set ( update_reg_xmm' x v s )
let update_flags (new_flags:flags_t) : st unit =
let* s = get in
set ( { s with ms_flags = new_flags } )
let update_cf (new_cf:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' s.ms_flags new_cf } )
let update_of (new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_of' s.ms_flags new_of } )
let update_cf_of (new_cf new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' (update_of' s.ms_flags new_of) new_cf } )
let free_stack (start finish:int) : st unit =
let* s = get in
set ( { s with ms_stack = free_stack' start finish s.ms_stack} )
let bind_option (#a #b:Type) (v:option a) (f:a -> option b) : option b =
match v with
| None -> None
| Some x -> f x
let operand_obs (s:machine_state) (o:operand64) : list observation =
match o with
| OConst _ | OReg _ -> []
| OMem (m, _) | OStack (m, _) -> [MemAccess (eval_maddr m s)]
[@instr_attr]
let operand_obs128 (s:machine_state) (op:operand128) : list observation =
match op with
| OConst _ | OReg _ -> []
| OMem (m, _) | OStack (m, _) -> [MemAccess (eval_maddr m s)]
[@instr_attr]
let obs_operand_explicit
(i:instr_operand_explicit)
(o:instr_operand_t i)
(s:machine_state) : list observation =
match i with
| IOp64 -> operand_obs s o
| IOpXmm -> operand_obs128 s o
[@instr_attr]
let obs_operand_implicit
(i:instr_operand_implicit)
(s:machine_state) : list observation =
match i with
| IOp64One o -> operand_obs s o
| IOpXmmOne o -> operand_obs128 s o
| IOpFlagsCf | IOpFlagsOf -> []
[@instr_attr]
let rec obs_args
(args:list instr_operand)
(oprs:instr_operands_t_args args)
(s:machine_state) : list observation =
match args with
| [] -> []
| i::args ->
match i with
| IOpEx i ->
let oprs = coerce oprs in
obs_operand_explicit i (fst oprs) s @ obs_args args (snd oprs) s
| IOpIm i ->
obs_operand_implicit i s @ obs_args args (coerce oprs) s
[@instr_attr]
let rec obs_inouts
(inouts:list instr_out)
(args:list instr_operand)
(oprs:instr_operands_t inouts args)
(s:machine_state) : list observation =
match inouts with
| [] -> obs_args args oprs s
| (_, i)::inouts ->
let (v, oprs) =
match i with
| IOpEx i ->
let oprs = coerce oprs in
(obs_operand_explicit i (fst oprs) s), snd oprs
| IOpIm i -> obs_operand_implicit i s, coerce oprs
in v @ obs_inouts inouts args oprs s
[@instr_attr]
let ins_obs (ins:ins) (s:machine_state) : list observation =
match ins with
| BC.Instr (InstrTypeRecord #outs #args _) oprs _ -> obs_inouts outs args oprs s
| BC.Push src _ -> operand_obs s src
| BC.Pop dst _ -> operand_obs s dst
| BC.Alloc _ | BC.Dealloc _ -> []
[@instr_attr]
let instr_eval_operand_explicit (i:instr_operand_explicit) (o:instr_operand_t i) (s:machine_state) : option (instr_val_t (IOpEx i)) =
match i with
| IOp64 -> if valid_src_operand64_and_taint o s then Some (eval_operand o s) else None
| IOpXmm -> if valid_src_operand128_and_taint o s then Some (eval_mov128_op o s) else None
[@instr_attr]
let instr_eval_operand_implicit (i:instr_operand_implicit) (s:machine_state) : option (instr_val_t (IOpIm i)) =
match i with
| IOp64One o -> if valid_src_operand64_and_taint o s then Some (eval_operand o s) else None
| IOpXmmOne o -> if valid_src_operand128_and_taint o s then Some (eval_mov128_op o s) else None
| IOpFlagsCf -> cf s.ms_flags
| IOpFlagsOf -> overflow s.ms_flags
[@instr_attr]
let rec instr_apply_eval_args
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args) (s:machine_state)
: option (instr_ret_t outs) =
match args with
| [] -> f
| i::args ->
let (v, oprs) =
match i with
| IOpEx i -> let oprs = coerce oprs in (instr_eval_operand_explicit i (fst oprs) s, snd oprs)
| IOpIm i -> (instr_eval_operand_implicit i s, coerce oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
bind_option v (fun v -> instr_apply_eval_args outs args (f v) oprs s)
[@instr_attr]
let rec instr_apply_eval_inouts
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args) (s:machine_state)
: option (instr_ret_t outs) =
match inouts with
| [] -> instr_apply_eval_args outs args f oprs s
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
instr_apply_eval_inouts outs inouts args (coerce f) oprs s
| (InOut, i)::inouts ->
let (v, oprs) =
match i with
| IOpEx i -> let oprs = coerce oprs in (instr_eval_operand_explicit i (fst oprs) s, snd oprs)
| IOpIm i -> (instr_eval_operand_implicit i s, coerce oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
bind_option v (fun v -> instr_apply_eval_inouts outs inouts args (f v) oprs s)
(*
Take the all the input operands for an instruction and:
- check that they are valid
- evaluate them
- apply the instruction's evaluator function f to the evaluated operands
*)
[@instr_attr]
let instr_apply_eval
(outs:list instr_out) (args:list instr_operand)
(f:instr_eval_t outs args) (oprs:instr_operands_t outs args) (s:machine_state) | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val instr_apply_eval
(outs: list instr_out)
(args: list instr_operand)
(f: instr_eval_t outs args)
(oprs: instr_operands_t outs args)
(s: machine_state)
: option (instr_ret_t outs) | [] | Vale.X64.Machine_Semantics_s.instr_apply_eval | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
outs: Prims.list Vale.X64.Instruction_s.instr_out ->
args: Prims.list Vale.X64.Instruction_s.instr_operand ->
f: Vale.X64.Instruction_s.instr_eval_t outs args ->
oprs: Vale.X64.Instruction_s.instr_operands_t outs args ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Native.option (Vale.X64.Instruction_s.instr_ret_t outs) | {
"end_col": 49,
"end_line": 615,
"start_col": 2,
"start_line": 615
} |
Prims.Tot | val update_rsp (i: int) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s) | val update_rsp (i: int) : st unit
let update_rsp (i: int) : st unit = | false | null | false | let* _ = check (fun s -> i >= s.ms_stack.initial_rsp - 4096) in
let* _ = check (fun s -> i <= s.ms_stack.initial_rsp) in
let* s = get in
set (update_rsp' i s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.check",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Subtraction",
"Vale.X64.Machine_Semantics_s.__proj__Machine_stack__item__initial_rsp",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Prims.bool",
"Prims.op_LessThanOrEqual",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.update_rsp'",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit = | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_rsp (i: int) : st unit | [] | Vale.X64.Machine_Semantics_s.update_rsp | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Prims.int -> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 22,
"end_line": 443,
"start_col": 1,
"start_line": 440
} |
Prims.Tot | val update_xmm_preserve_flags (x: reg_xmm) (v: quad32) : st unit | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_xmm_preserve_flags (x:reg_xmm) (v:quad32) : st unit =
let* s = get in
set ( update_reg_xmm' x v s ) | val update_xmm_preserve_flags (x: reg_xmm) (v: quad32) : st unit
let update_xmm_preserve_flags (x: reg_xmm) (v: quad32) : st unit = | false | null | false | let* s = get in
set (update_reg_xmm' x v s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.Def.Types_s.quad32",
"Vale.X64.Machine_Semantics_s.op_let_Star",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.unit",
"Vale.X64.Machine_Semantics_s.get",
"Vale.X64.Machine_Semantics_s.set",
"Vale.X64.Machine_Semantics_s.update_reg_xmm'",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s)
let update_reg_64 (r:reg_64) (v:nat64) : st unit =
let* s = get in
set (update_reg_64' r v s)
let update_reg_xmm (x:reg_xmm) (ins:ins) (v:quad32) : st unit =
let* s = get in
set ( { (update_reg_xmm' x v s) with ms_flags = havoc_flags } ) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_xmm_preserve_flags (x: reg_xmm) (v: quad32) : st unit | [] | Vale.X64.Machine_Semantics_s.update_xmm_preserve_flags | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.X64.Machine_s.reg_xmm -> v: Vale.Def.Types_s.quad32
-> Vale.X64.Machine_Semantics_s.st Prims.unit | {
"end_col": 31,
"end_line": 455,
"start_col": 2,
"start_line": 454
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let flag_val_t = option bool | let flag_val_t = | false | null | false | option bool | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val flag_val_t : Type0 | [] | Vale.X64.Machine_Semantics_s.flag_val_t | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 35,
"end_line": 56,
"start_col": 24,
"start_line": 56
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let code = BC.code_t instr_annotation | let code = | false | null | false | BC.code_t instr_annotation | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val code : Type0 | [] | Vale.X64.Machine_Semantics_s.code | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 37,
"end_line": 46,
"start_col": 11,
"start_line": 46
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins = BC.instruction_t instr_annotation | let ins = | false | null | false | BC.instruction_t instr_annotation | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins : Type0 | [] | Vale.X64.Machine_Semantics_s.ins | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 43,
"end_line": 44,
"start_col": 10,
"start_line": 44
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ocmp = BC.ocmp | let ocmp = | false | null | false | BC.ocmp | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Bytes_Code_s.ocmp"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ocmp : Prims.eqtype | [] | Vale.X64.Machine_Semantics_s.ocmp | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.eqtype | {
"end_col": 18,
"end_line": 45,
"start_col": 11,
"start_line": 45
} |
|
Prims.Tot | val eval_stack128 (ptr: int) (s: machine_stack) : quad32 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem | val eval_stack128 (ptr: int) (s: machine_stack) : quad32
let eval_stack128 (ptr: int) (s: machine_stack) : quad32 = | false | null | false | let Machine_stack _ mem = s in
get_heap_val128 ptr mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.Arch.MachineHeap_s.get_heap_val128",
"Vale.Def.Types_s.quad32"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_stack128 (ptr: int) (s: machine_stack) : quad32 | [] | Vale.X64.Machine_Semantics_s.eval_stack128 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.X64.Machine_Semantics_s.machine_stack -> Vale.Def.Types_s.quad32 | {
"end_col": 25,
"end_line": 92,
"start_col": 63,
"start_line": 90
} |
Prims.Tot | val eval_stack (ptr: int) (s: machine_stack) : nat64 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem | val eval_stack (ptr: int) (s: machine_stack) : nat64
let eval_stack (ptr: int) (s: machine_stack) : nat64 = | false | null | false | let Machine_stack _ mem = s in
get_heap_val64 ptr mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.Arch.MachineHeap_s.get_heap_val64"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_stack (ptr: int) (s: machine_stack) : nat64 | [] | Vale.X64.Machine_Semantics_s.eval_stack | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.X64.Machine_Semantics_s.machine_stack -> Vale.Def.Types_s.nat64 | {
"end_col": 24,
"end_line": 89,
"start_col": 59,
"start_line": 87
} |
Prims.Tot | val eval_mem128 (ptr: int) (s: machine_state) : quad32 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap) | val eval_mem128 (ptr: int) (s: machine_state) : quad32
let eval_mem128 (ptr: int) (s: machine_state) : quad32 = | false | null | false | get_heap_val128 ptr (heap_get s.ms_heap) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Arch.MachineHeap_s.get_heap_val128",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.Def.Types_s.quad32"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_mem128 (ptr: int) (s: machine_state) : quad32 | [] | Vale.X64.Machine_Semantics_s.eval_mem128 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.X64.Machine_Semantics_s.machine_state -> Vale.Def.Types_s.quad32 | {
"end_col": 102,
"end_line": 85,
"start_col": 62,
"start_line": 85
} |
Prims.Tot | val update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem | val update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack
let update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack = | false | null | false | let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.Def.Types_s.quad32",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.X64.Machine_Semantics_s.Machine_stack",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.MachineHeap_s.update_heap128"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack | [] | Vale.X64.Machine_Semantics_s.update_stack128' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> v: Vale.Def.Types_s.quad32 -> s: Vale.X64.Machine_Semantics_s.machine_stack
-> Vale.X64.Machine_Semantics_s.machine_stack | {
"end_col": 28,
"end_line": 229,
"start_col": 77,
"start_line": 226
} |
Prims.Tot | val valid_src_stack128 (ptr: int) (st: machine_stack) : bool | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem | val valid_src_stack128 (ptr: int) (st: machine_stack) : bool
let valid_src_stack128 (ptr: int) (st: machine_stack) : bool = | false | null | false | let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.Arch.MachineHeap_s.valid_addr128",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_src_stack128 (ptr: int) (st: machine_stack) : bool | [] | Vale.X64.Machine_Semantics_s.valid_src_stack128 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> st: Vale.X64.Machine_Semantics_s.machine_stack -> Prims.bool | {
"end_col": 23,
"end_line": 253,
"start_col": 60,
"start_line": 251
} |
Prims.Tot | val update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem | val update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack
let update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack = | false | null | false | let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.X64.Machine_Semantics_s.Machine_stack",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.MachineHeap_s.update_heap64"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack | [] | Vale.X64.Machine_Semantics_s.update_stack64' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> v: Vale.Def.Types_s.nat64 -> s: Vale.X64.Machine_Semantics_s.machine_stack
-> Vale.X64.Machine_Semantics_s.machine_stack | {
"end_col": 28,
"end_line": 223,
"start_col": 75,
"start_line": 220
} |
Prims.Tot | val free_stack' (start finish: int) (st: machine_stack) : machine_stack | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem | val free_stack' (start finish: int) (st: machine_stack) : machine_stack
let free_stack' (start finish: int) (st: machine_stack) : machine_stack = | false | null | false | let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.Def.Types_s.nat8",
"Vale.X64.Machine_Semantics_s.Machine_stack",
"Vale.Def.Words_s.nat8",
"FStar.Map.restrict",
"FStar.Set.set",
"Vale.Lib.Set.remove_between",
"FStar.Map.domain"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f) | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val free_stack' (start finish: int) (st: machine_stack) : machine_stack | [] | Vale.X64.Machine_Semantics_s.free_stack' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | start: Prims.int -> finish: Prims.int -> st: Vale.X64.Machine_Semantics_s.machine_stack
-> Vale.X64.Machine_Semantics_s.machine_stack | {
"end_col": 32,
"end_line": 375,
"start_col": 71,
"start_line": 368
} |
Prims.Tot | val update_operand128_preserve_flags' (o: operand128) (v: quad32) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s | val update_operand128_preserve_flags' (o: operand128) (v: quad32) (s: machine_state) : machine_state
let update_operand128_preserve_flags' (o: operand128) (v: quad32) (s: machine_state) : machine_state = | false | null | false | update_operand128_preserve_flags'' o v s s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.operand128",
"Vale.Def.Types_s.quad32",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.update_operand128_preserve_flags''"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_operand128_preserve_flags' (o: operand128) (v: quad32) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_operand128_preserve_flags' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
o: Vale.X64.Machine_s.operand128 ->
v: Vale.Def.Types_s.quad32 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 44,
"end_line": 339,
"start_col": 2,
"start_line": 339
} |
Prims.Tot | val cf (flags: flags_t) : flag_val_t | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let cf (flags:flags_t) : flag_val_t =
flags fCarry | val cf (flags: flags_t) : flag_val_t
let cf (flags: flags_t) : flag_val_t = | false | null | false | flags fCarry | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.flags_t",
"Vale.X64.Machine_s.fCarry",
"Vale.X64.Machine_Semantics_s.flag_val_t"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val cf (flags: flags_t) : flag_val_t | [] | Vale.X64.Machine_Semantics_s.cf | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | flags: Vale.X64.Machine_Semantics_s.flags_t -> Vale.X64.Machine_Semantics_s.flag_val_t | {
"end_col": 14,
"end_line": 357,
"start_col": 2,
"start_line": 357
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let st (a:Type) = machine_state -> a & machine_state | let st (a: Type) = | false | null | false | machine_state -> a & machine_state | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.tuple2"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val st : a: Type -> Type | [] | Vale.X64.Machine_Semantics_s.st | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Type -> Type | {
"end_col": 52,
"end_line": 378,
"start_col": 18,
"start_line": 378
} |
|
Prims.Tot | val havoc_flags:flags_t | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none | val havoc_flags:flags_t
let havoc_flags:flags_t = | false | null | false | FStar.FunctionalExtensionality.on_dom flag flags_none | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"FStar.FunctionalExtensionality.on_dom",
"Vale.X64.Machine_s.flag",
"Vale.X64.Machine_Semantics_s.flag_val_t",
"Vale.X64.Machine_Semantics_s.flags_none"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val havoc_flags:flags_t | [] | Vale.X64.Machine_Semantics_s.havoc_flags | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Machine_Semantics_s.flags_t | {
"end_col": 81,
"end_line": 342,
"start_col": 28,
"start_line": 342
} |
Prims.Tot | val return (#a: Type) (x: a) : st a | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let return (#a:Type) (x:a) : st a =
fun s -> (x, s) | val return (#a: Type) (x: a) : st a
let return (#a: Type) (x: a) : st a = | false | null | false | fun s -> (x, s) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Machine_Semantics_s.st"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val return (#a: Type) (x: a) : st a | [] | Vale.X64.Machine_Semantics_s.return | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: a -> Vale.X64.Machine_Semantics_s.st a | {
"end_col": 17,
"end_line": 382,
"start_col": 2,
"start_line": 382
} |
Prims.Tot | val update_reg' (r: reg) (v: t_reg r) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')} | val update_reg' (r: reg) (v: t_reg r) (s: machine_state) : machine_state
let update_reg' (r: reg) (v: t_reg r) (s: machine_state) : machine_state = | false | null | false | {
s with
ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')
} | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"FStar.FunctionalExtensionality.on_dom",
"Prims.op_Equality",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_reg' (r: reg) (v: t_reg r) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_reg' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
r: Vale.X64.Machine_s.reg ->
v: Vale.X64.Machine_s.t_reg r ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 108,
"end_line": 127,
"start_col": 3,
"start_line": 127
} |
Prims.Tot | val update_reg_64' (r: reg_64) (v: nat64) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s | val update_reg_64' (r: reg_64) (v: nat64) (s: machine_state) : machine_state
let update_reg_64' (r: reg_64) (v: nat64) (s: machine_state) : machine_state = | false | null | false | update_reg' (Reg 0 r) v s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg_64",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.update_reg'",
"Vale.X64.Machine_s.Reg"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')} | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_reg_64' (r: reg_64) (v: nat64) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_reg_64' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
r: Vale.X64.Machine_s.reg_64 ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 27,
"end_line": 130,
"start_col": 2,
"start_line": 130
} |
Prims.Tot | val eval_reg_xmm (r: reg_xmm) (s: machine_state) : quad32 | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s | val eval_reg_xmm (r: reg_xmm) (s: machine_state) : quad32
let eval_reg_xmm (r: reg_xmm) (s: machine_state) : quad32 = | false | null | false | eval_reg (Reg 1 r) s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.eval_reg",
"Vale.X64.Machine_s.Reg",
"Vale.Def.Types_s.quad32"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_reg_xmm (r: reg_xmm) (s: machine_state) : quad32 | [] | Vale.X64.Machine_Semantics_s.eval_reg_xmm | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.X64.Machine_s.reg_xmm -> s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.Def.Types_s.quad32 | {
"end_col": 85,
"end_line": 80,
"start_col": 65,
"start_line": 80
} |
Prims.Tot | val update_reg_xmm' (r: reg_xmm) (v: quad32) (s: machine_state) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s | val update_reg_xmm' (r: reg_xmm) (v: quad32) (s: machine_state) : machine_state
let update_reg_xmm' (r: reg_xmm) (v: quad32) (s: machine_state) : machine_state = | false | null | false | update_reg' (Reg 1 r) v s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.Def.Types_s.quad32",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Machine_Semantics_s.update_reg'",
"Vale.X64.Machine_s.Reg"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_reg_xmm' (r: reg_xmm) (v: quad32) (s: machine_state) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_reg_xmm' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
r: Vale.X64.Machine_s.reg_xmm ->
v: Vale.Def.Types_s.quad32 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 27,
"end_line": 133,
"start_col": 2,
"start_line": 133
} |
FStar.Pervasives.Lemma | val lemma_is_machine_heap_update128 (ptr: int) (v: quad32) (mh: machine_heap)
: Lemma (requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))] | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3 | val lemma_is_machine_heap_update128 (ptr: int) (v: quad32) (mh: machine_heap)
: Lemma (requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
let lemma_is_machine_heap_update128 (ptr: int) (v: quad32) (mh: machine_heap)
: Lemma (requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))] = | false | null | true | let lemma_is_machine_heap_update32 (ptr: int) (v: nat32) (mh: machine_heap)
: Lemma
(requires
valid_addr ptr mh /\ valid_addr (ptr + 1) mh /\ valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh) (ensures is_machine_heap_update mh (update_heap32 ptr v mh)) =
update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3 | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"lemma"
] | [
"Prims.int",
"Vale.Def.Types_s.quad32",
"Vale.Arch.MachineHeap_s.machine_heap",
"Prims.op_Addition",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Prims.unit",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Arch.MachineHeap_s.update_heap128_reveal",
"FStar.Pervasives.reveal_opaque",
"Prims.bool",
"Vale.Arch.MachineHeap_s.valid_addr128",
"Vale.Arch.MachineHeap_s.update_heap32",
"Vale.Def.Words_s.nat32",
"Prims.l_and",
"Prims.b2t",
"Vale.Arch.MachineHeap_s.valid_addr",
"Prims.squash",
"Vale.Arch.MachineHeap_s.is_machine_heap_update",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Arch.MachineHeap_s.update_heap32_reveal",
"Vale.Arch.MachineHeap_s.update_heap128",
"Prims.Cons",
"FStar.Pervasives.smt_pat",
"Prims.logical"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh)) | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_is_machine_heap_update128 (ptr: int) (v: quad32) (mh: machine_heap)
: Lemma (requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))] | [] | Vale.X64.Machine_Semantics_s.lemma_is_machine_heap_update128 | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> v: Vale.Def.Types_s.quad32 -> mh: Vale.Arch.MachineHeap_s.machine_heap
-> FStar.Pervasives.Lemma (requires Vale.Arch.MachineHeap_s.valid_addr128 ptr mh)
(ensures
Vale.Arch.MachineHeap_s.is_machine_heap_update mh
(Vale.Arch.MachineHeap_s.update_heap128 ptr v mh))
[
SMTPat (Vale.Arch.MachineHeap_s.is_machine_heap_update mh
(Vale.Arch.MachineHeap_s.update_heap128 ptr v mh))
] | {
"end_col": 54,
"end_line": 208,
"start_col": 3,
"start_line": 189
} |
Prims.Tot | val update_mem_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s | val update_mem_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state
let update_mem_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state = | false | null | false | if valid_addr64 ptr (heap_get s.ms_heap)
then
{
s with
ms_heap
=
heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.Arch.HeapTypes_s.taint",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.Arch.Heap.heap_upd",
"Vale.Arch.MachineHeap_s.update_heap64",
"Vale.X64.Machine_Semantics_s.update_n",
"Vale.Arch.Heap.heap_taint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Prims.bool"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
() | false | true | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_mem_and_taint (ptr: int) (v: nat64) (s: machine_state) (t: taint) : machine_state | [] | Vale.X64.Machine_Semantics_s.update_mem_and_taint | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ptr: Prims.int ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.X64.Machine_Semantics_s.machine_state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.X64.Machine_Semantics_s.machine_state | {
"end_col": 8,
"end_line": 183,
"start_col": 2,
"start_line": 177
} |
Prims.Tot | val bind_option (#a #b: Type) (v: option a) (f: (a -> option b)) : option b | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind_option (#a #b:Type) (v:option a) (f:a -> option b) : option b =
match v with
| None -> None
| Some x -> f x | val bind_option (#a #b: Type) (v: option a) (f: (a -> option b)) : option b
let bind_option (#a #b: Type) (v: option a) (f: (a -> option b)) : option b = | false | null | false | match v with
| None -> None
| Some x -> f x | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow
let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f)
let update_of' (flags:flags_t) (new_of:bool) : (new_flags:flags_t{overflow new_flags == Some new_of}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fOverflow then Some new_of else flags f)
let free_stack' (start finish:int) (st:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = st in
let domain = Map.domain mem in
// Returns the domain, without elements between start and finish
let restricted_domain = Vale.Lib.Set.remove_between domain start finish in
// The new domain of the stack does not contain elements between start and finish
let new_mem = Map.restrict restricted_domain mem in
Machine_stack init_rsp new_mem
// Define a stateful monad to simplify defining the instruction semantics
let st (a:Type) = machine_state -> a & machine_state
unfold
let return (#a:Type) (x:a) : st a =
fun s -> (x, s)
unfold
let (let*) (#a:Type) (#b:Type) (m:st a) (f:a -> st b) : st b =
fun s0 ->
let (x, s1) = m s0 in
let (y, s2) = f x s1 in
(y, {s2 with ms_ok = s0.ms_ok && s1.ms_ok && s2.ms_ok})
unfold
let get : st machine_state =
fun s -> (s, s)
unfold
let set (s:machine_state) : st unit =
fun _ -> ((), s)
unfold
let fail : st unit =
fun s -> ((), {s with ms_ok = false})
unfold
let check_imm (valid:bool) : st unit =
if valid then
return ()
else
fail
unfold
let check (valid: machine_state -> bool) : st unit =
let* s = get in
if valid s then
return ()
else
fail
unfold
let try_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
match o with
| None -> fail
| Some x -> f x
let apply_option (#a:Type) (o:option a) (f:a -> st unit) : st unit =
try_option o f
unfold
let run (f:st unit) (s:machine_state) : machine_state = snd (f s)
// Monadic update operations
unfold
let update_operand64_preserve_flags (dst:operand64) (v:nat64) : st unit =
check (valid_dst_operand64 dst);*
let* s = get in
set (update_operand64_preserve_flags' dst v s)
unfold
let update_rsp (i:int) : st unit =
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
check (fun s -> i >= s.ms_stack.initial_rsp - 4096);*
check (fun s -> i <= s.ms_stack.initial_rsp);*
let* s = get in
set (update_rsp' i s)
let update_reg_64 (r:reg_64) (v:nat64) : st unit =
let* s = get in
set (update_reg_64' r v s)
let update_reg_xmm (x:reg_xmm) (ins:ins) (v:quad32) : st unit =
let* s = get in
set ( { (update_reg_xmm' x v s) with ms_flags = havoc_flags } )
let update_xmm_preserve_flags (x:reg_xmm) (v:quad32) : st unit =
let* s = get in
set ( update_reg_xmm' x v s )
let update_flags (new_flags:flags_t) : st unit =
let* s = get in
set ( { s with ms_flags = new_flags } )
let update_cf (new_cf:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' s.ms_flags new_cf } )
let update_of (new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_of' s.ms_flags new_of } )
let update_cf_of (new_cf new_of:bool) : st unit =
let* s = get in
set ( { s with ms_flags = update_cf' (update_of' s.ms_flags new_of) new_cf } )
let free_stack (start finish:int) : st unit =
let* s = get in
set ( { s with ms_stack = free_stack' start finish s.ms_stack} ) | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind_option (#a #b: Type) (v: option a) (f: (a -> option b)) : option b | [] | Vale.X64.Machine_Semantics_s.bind_option | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | v: FStar.Pervasives.Native.option a -> f: (_: a -> FStar.Pervasives.Native.option b)
-> FStar.Pervasives.Native.option b | {
"end_col": 17,
"end_line": 480,
"start_col": 2,
"start_line": 478
} |
Prims.Tot | val update_cf' (flags: flags_t) (new_cf: bool) : (new_flags: flags_t{cf new_flags == Some new_cf}) | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_cf' (flags:flags_t) (new_cf:bool) : (new_flags:flags_t{cf new_flags == Some new_cf}) =
FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f) | val update_cf' (flags: flags_t) (new_cf: bool) : (new_flags: flags_t{cf new_flags == Some new_cf})
let update_cf' (flags: flags_t) (new_cf: bool) : (new_flags: flags_t{cf new_flags == Some new_cf}) = | false | null | false | FStar.FunctionalExtensionality.on_dom flag (fun f -> if f = fCarry then Some new_cf else flags f) | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.flags_t",
"Prims.bool",
"FStar.FunctionalExtensionality.on_dom",
"Vale.X64.Machine_s.flag",
"FStar.Pervasives.Native.option",
"Prims.op_Equality",
"Vale.X64.Machine_s.fCarry",
"FStar.Pervasives.Native.Some",
"Prims.eq2",
"Vale.X64.Machine_Semantics_s.cf"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t
[@"opaque_to_smt"]
let rec update_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (m:memTaint_t{(
forall i.{:pattern (m `Map.sel` i)}
((i >= addr /\ i < addr + n) ==> m.[i] == t) /\
((i < addr \/ i >= addr + n) ==> m.[i] == memTaint.[i]))})
(decreases n)
=
if n = 0 then memTaint
else update_n (addr + 1) (n - 1) (memTaint.[addr] <- t) t
let lemma_is_machine_heap_update64 (ptr:int) (v:nat64) (mh:machine_heap) : Lemma
(requires valid_addr64 ptr mh)
(ensures is_machine_heap_update mh (update_heap64 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap64 ptr v mh))]
=
reveal_opaque (`%valid_addr64) valid_addr64;
update_heap64_reveal ();
()
let update_mem_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
if valid_addr64 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap64 ptr v (heap_get s.ms_heap))
(update_n ptr 8 (heap_taint s.ms_heap) t)
}
else s
let lemma_is_machine_heap_update128 (ptr:int) (v:quad32) (mh:machine_heap) : Lemma
(requires valid_addr128 ptr mh)
(ensures is_machine_heap_update mh (update_heap128 ptr v mh))
[SMTPat (is_machine_heap_update mh (update_heap128 ptr v mh))]
=
let lemma_is_machine_heap_update32 (ptr:int) (v:nat32) (mh:machine_heap) : Lemma
(requires
valid_addr ptr mh /\
valid_addr (ptr + 1) mh /\
valid_addr (ptr + 2) mh /\
valid_addr (ptr + 3) mh
)
(ensures is_machine_heap_update mh (update_heap32 ptr v mh))
= update_heap32_reveal ()
in
let mem1 = update_heap32 ptr v.lo0 mh in
let mem2 = update_heap32 (ptr + 4) v.lo1 mem1 in
let mem3 = update_heap32 (ptr + 8) v.hi2 mem2 in
reveal_opaque (`%valid_addr128) valid_addr128;
update_heap128_reveal ();
lemma_is_machine_heap_update32 ptr v.lo0 mh;
lemma_is_machine_heap_update32 (ptr + 4) v.lo1 mem1;
lemma_is_machine_heap_update32 (ptr + 8) v.hi2 mem2;
lemma_is_machine_heap_update32 (ptr + 12) v.hi3 mem3
let update_mem128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
if valid_addr128 ptr (heap_get s.ms_heap) then
{ s with
ms_heap = heap_upd s.ms_heap
(update_heap128 ptr v (heap_get s.ms_heap))
(update_n ptr 16 (heap_taint s.ms_heap) t)
}
else s
unfold
let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_rsp mem
unfold
let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_rsp mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_rsp mem
let update_stack_and_taint (ptr:int) (v:nat64) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack64' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 8 s.ms_stackTaint t;
}
let update_stack128_and_taint (ptr:int) (v:quad32) (s:machine_state) (t:taint) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
{ s with
ms_stack = update_stack128' ptr v s.ms_stack;
ms_stackTaint = update_n ptr 16 s.ms_stackTaint t
}
unfold
let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr64 ptr mem
unfold
let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
valid_addr128 ptr mem
let valid_src_operand (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, t) -> valid_src_stack64 (eval_maddr m s) s.ms_stack
let valid_src_operand64_and_taint (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> true
| OReg r -> true
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr64 ptr (heap_get s.ms_heap) && match_n ptr 8 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t
let valid_src_operand128_and_taint (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, t) ->
let ptr = eval_maddr m s in
valid_addr128 ptr (heap_get s.ms_heap) && match_n ptr 16 (heap_taint s.ms_heap) t
| OStack (m, t) ->
let ptr = eval_maddr m s in
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t
let valid_ocmp (c:ocmp) (s:machine_state) : bool =
match c with
| BC.OEq o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.ONe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGe o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OLt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
| BC.OGt o1 o2 -> valid_src_operand64_and_taint o1 s && valid_src_operand64_and_taint o2 s
[@"opaque_to_smt"]
let valid_ocmp_opaque (c:ocmp) (s:machine_state) : bool = valid_ocmp c s
unfold
let valid_dst_stack64 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 8 <= init_rsp
unfold
let valid_dst_stack128 (rsp:nat64) (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_rsp mem = st in
// We are allowed to store anywhere between rRsp and the initial stack pointer
ptr >= rsp && ptr + 16 <= init_rsp
let valid_dst_operand64 (o:operand64) (s:machine_state) : bool =
match o with
| OConst n -> false
| OReg r -> not (rRsp = r)
| OMem (m, _) -> valid_addr64 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack64 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let valid_dst_operand128 (o:operand128) (s:machine_state) : bool =
match o with
| OConst _ -> false
| OReg i -> true // We leave it to the printer/assembler to object to invalid XMM indices
| OMem (m, _) -> valid_addr128 (eval_maddr m s) (heap_get s.ms_heap)
| OStack (m, _) -> valid_dst_stack128 (eval_reg_64 rRsp s) (eval_maddr m s) s.ms_stack
let update_operand64_preserve_flags'' (o:operand64) (v:nat64) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg r -> update_reg_64' r v s
| OMem (m, t) -> update_mem_and_taint (eval_maddr m s_orig) v s t // see valid_buf_maddr64 for how eval_maddr connects to b and i
| OStack (m, t) -> update_stack_and_taint (eval_maddr m s_orig) v s t
let update_operand64_preserve_flags' (o:operand64) (v:nat64) (s:machine_state) : machine_state =
update_operand64_preserve_flags'' o v s s
let update_operand128_preserve_flags'' (o:operand128) (v:quad32) (s_orig s:machine_state) : machine_state =
match o with
| OConst _ -> {s with ms_ok = false}
| OReg i -> update_reg_xmm' i v s
| OMem (m, t) -> update_mem128_and_taint (eval_maddr m s_orig) v s t
| OStack (m, t) -> update_stack128_and_taint (eval_maddr m s_orig) v s t
let update_operand128_preserve_flags' (o:operand128) (v:quad32) (s:machine_state) : machine_state =
update_operand128_preserve_flags'' o v s s
let flags_none (f:flag) : flag_val_t = None
let havoc_flags : flags_t = FStar.FunctionalExtensionality.on_dom flag flags_none
// Default version havocs flags
let update_operand64' (o:operand64) (ins:ins) (v:nat64) (s:machine_state) : machine_state =
{ (update_operand64_preserve_flags' o v s) with ms_flags = havoc_flags }
let update_rsp' (new_rsp:int) (s:machine_state) : machine_state =
let Machine_stack init_rsp mem = s.ms_stack in
// Only modify the stack pointer if the new value is valid, that is in the current stack frame, and in the same page
if new_rsp >= init_rsp - 4096 && new_rsp <= init_rsp then
update_reg_64' rRsp new_rsp s
else
s
let cf (flags:flags_t) : flag_val_t =
flags fCarry
let overflow(flags:flags_t) : flag_val_t =
flags fOverflow | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_cf' (flags: flags_t) (new_cf: bool) : (new_flags: flags_t{cf new_flags == Some new_cf}) | [] | Vale.X64.Machine_Semantics_s.update_cf' | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | flags: Vale.X64.Machine_Semantics_s.flags_t -> new_cf: Prims.bool
-> new_flags:
Vale.X64.Machine_Semantics_s.flags_t
{Vale.X64.Machine_Semantics_s.cf new_flags == FStar.Pervasives.Native.Some new_cf} | {
"end_col": 99,
"end_line": 363,
"start_col": 2,
"start_line": 363
} |
Prims.Tot | val match_n (addr: int) (n: nat) (memTaint: memTaint_t) (t: taint)
: Tot
(b:
bool
{ b <==>
(forall i. {:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[ i ] == t) }) (decreases n) | [
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) memTaint t | val match_n (addr: int) (n: nat) (memTaint: memTaint_t) (t: taint)
: Tot
(b:
bool
{ b <==>
(forall i. {:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[ i ] == t) }) (decreases n)
let rec match_n (addr: int) (n: nat) (memTaint: memTaint_t) (t: taint)
: Tot
(b:
bool
{ b <==>
(forall i. {:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[ i ] == t) }) (decreases n) = | false | null | false | if n = 0
then true
else if memTaint.[ addr ] <> t then false else match_n (addr + 1) (n - 1) memTaint t | {
"checked_file": "Vale.X64.Machine_Semantics_s.fst.checked",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Machine_Semantics_s.fst"
} | [
"total",
""
] | [
"Prims.int",
"Prims.nat",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.Arch.HeapTypes_s.taint",
"Prims.op_Equality",
"Prims.bool",
"Prims.op_disEquality",
"Vale.X64.Machine_Semantics_s.op_String_Access",
"Vale.X64.Machine_Semantics_s.match_n",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Prims.l_iff",
"Prims.b2t",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Map.sel"
] | [] | module Vale.X64.Machine_Semantics_s
open FStar.Mul
open FStar.List.Tot
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.CPU_Features_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open FStar.Seq.Base
module BC = Vale.X64.Bytes_Code_s
//type uint64:eqtype = UInt64.t
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
//TODO: [@"opaque_to_smt"]
let equals_instr (x1 x2:instr_t_record) : Type0 =
squash (x1 == x2)
noeq type instr_annotation (it:instr_t_record) =
| AnnotateNone : instr_annotation it
| AnnotateXor64 : equals_instr it (InstrTypeRecord ins_Xor64) -> instr_annotation it
| AnnotatePxor : equals_instr it (InstrTypeRecord ins_Pxor) -> instr_annotation it
| AnnotateVPxor : equals_instr it (InstrTypeRecord ins_VPxor) -> instr_annotation it
| AnnotateGhost : equals_instr it (InstrTypeRecord ins_Ghost) -> instr_annotation it
| AnnotateComment : s:string{it == (InstrTypeRecord (ins_Comment s))} -> instr_annotation it
| AnnotateLargeComment : s:string{it == (InstrTypeRecord (ins_LargeComment s))} -> instr_annotation it
| AnnotateNewline : equals_instr it (InstrTypeRecord ins_Newline) -> instr_annotation it
| AnnotateSpace : n:nat{it == (InstrTypeRecord (ins_Space n))} -> instr_annotation it
| AnnotateMovbe64 : equals_instr it (InstrTypeRecord ins_MovBe64) -> instr_annotation it
| AnnotateMov64 : equals_instr it (InstrTypeRecord ins_Mov64) -> instr_annotation it
| AnnotatePrefetchnta : equals_instr it (InstrTypeRecord ins_Prefetchnta) -> instr_annotation it
let ins = BC.instruction_t instr_annotation
let ocmp = BC.ocmp
let code = BC.code_t instr_annotation
let codes = BC.codes_t instr_annotation
noeq
type machine_stack =
| Machine_stack:
initial_rsp:nat64{initial_rsp >= 4096} -> // Initial rsp pointer when entering the function
stack_mem:Map.t int nat8 -> // Stack contents
machine_stack
unfold let flag_val_t = option bool // HACK: this shouldn't have to be unfolded (it has to do with the lambda in FStar.FunctionalExtensionality.(^->))
type flags_t = FStar.FunctionalExtensionality.restricted_t flag (fun _ -> flag_val_t)
type regs_t = FStar.FunctionalExtensionality.restricted_t reg t_reg
noeq
type machine_state = {
ms_ok: bool;
ms_regs: regs_t;
ms_flags: flags_t;
ms_heap: heap_impl;
ms_stack: machine_stack;
ms_stackTaint: memTaint_t;
ms_trace: list observation;
}
let get_fst_ocmp (o:ocmp) = match o with
| BC.OEq o1 _ | BC.ONe o1 _ | BC.OLe o1 _ | BC.OGe o1 _ | BC.OLt o1 _ | BC.OGt o1 _ -> o1
let get_snd_ocmp (o:ocmp) = match o with
| BC.OEq _ o2 | BC.ONe _ o2 | BC.OLe _ o2 | BC.OGe _ o2 | BC.OLt _ o2 | BC.OGt _ o2 -> o2
unfold let eval_reg (r:reg) (s:machine_state) : t_reg r = s.ms_regs r
unfold let eval_reg_64 (r:reg_64) (s:machine_state) : nat64 = eval_reg (Reg 0 r) s
unfold let eval_reg_xmm (r:reg_xmm) (s:machine_state) : quad32 = eval_reg (Reg 1 r) s
unfold let eval_reg_int (r:reg) (s:machine_state) : int = t_reg_to_int r.rf (eval_reg r s)
unfold let eval_mem (ptr:int) (s:machine_state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap)
unfold let eval_mem128 (ptr:int) (s:machine_state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap)
unfold let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem
unfold let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem
[@va_qattr]
let eval_maddr (m:maddr) (s:machine_state) : int =
match m with
| MConst n -> n
| MReg r offset -> (eval_reg_int r s) + offset
| MIndex base scale index offset -> (eval_reg_int base s) + scale * (eval_reg_int index s) + offset
let eval_operand (o:operand64) (s:machine_state) : nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s.ms_stack
let eval_mov128_op (o:operand128) (s:machine_state) : quad32 =
match o with
| OConst c -> c
| OReg i -> eval_reg_xmm i s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s.ms_stack
let eval_ocmp (s:machine_state) (c:ocmp) : bool =
match c with
| BC.OEq o1 o2 -> eval_operand o1 s = eval_operand o2 s
| BC.ONe o1 o2 -> eval_operand o1 s <> eval_operand o2 s
| BC.OLe o1 o2 -> eval_operand o1 s <= eval_operand o2 s
| BC.OGe o1 o2 -> eval_operand o1 s >= eval_operand o2 s
| BC.OLt o1 o2 -> eval_operand o1 s < eval_operand o2 s
| BC.OGt o1 o2 -> eval_operand o1 s > eval_operand o2 s
[@"opaque_to_smt"]
let eval_ocmp_opaque (s:machine_state) (c:ocmp) : bool = eval_ocmp s c
let update_reg' (r:reg) (v:t_reg r) (s:machine_state) : machine_state =
{s with ms_regs = FStar.FunctionalExtensionality.on_dom reg (fun r' -> if r' = r then v else s.ms_regs r')}
let update_reg_64' (r:reg_64) (v:nat64) (s:machine_state) : machine_state =
update_reg' (Reg 0 r) v s
let update_reg_xmm' (r:reg_xmm) (v:quad32) (s:machine_state) : machine_state =
update_reg' (Reg 1 r) v s
//val mod_8: (n:nat{n < pow2_64}) -> nat8
//let mod_8 n = n % 0x100
(*
Check if the taint annotation of a memory operand matches the taint in the memory map.
Evaluation will fail in case of a mismatch.
This allows the taint analysis to learn information about the memory map from the annotation,
assuming that the code has been verified not to fail.
(Note that this only relates to memory maps, so non-memory operands need no annotation.)
*)
[@"opaque_to_smt"]
let rec match_n (addr:int) (n:nat) (memTaint:memTaint_t) (t:taint)
: Tot (b:bool{b <==>
(forall i.{:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[i] == t)})
(decreases n) | false | false | Vale.X64.Machine_Semantics_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val match_n (addr: int) (n: nat) (memTaint: memTaint_t) (t: taint)
: Tot
(b:
bool
{ b <==>
(forall i. {:pattern (memTaint `Map.sel` i)}
(i >= addr /\ i < addr + n) ==> memTaint.[ i ] == t) }) (decreases n) | [
"recursion"
] | Vale.X64.Machine_Semantics_s.match_n | {
"file_name": "vale/specs/hardware/Vale.X64.Machine_Semantics_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
addr: Prims.int ->
n: Prims.nat ->
memTaint: Vale.Arch.HeapTypes_s.memTaint_t ->
t: Vale.Arch.HeapTypes_s.taint
-> Prims.Tot
(b:
Prims.bool
{ b <==>
(forall (i: Prims.int). {:pattern FStar.Map.sel memTaint i}
i >= addr /\ i < addr + n ==> memTaint.[ i ] == t) }) | {
"end_col": 44,
"end_line": 154,
"start_col": 2,
"start_line": 152
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.