file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.AsLowStar.MemoryHelpers.fst | Vale.AsLowStar.MemoryHelpers.bounded_buffer_addrs_one | val bounded_buffer_addrs_one (src t:base_typ) (h:HS.mem) (b:buf_t src t{B.live h b}) (s:ME.vale_heap) : Lemma
(ME.buffer_addr #t (as_vale_buffer b) s + DV.length (get_downview b) < Vale.Def.Words_s.pow2_64) | val bounded_buffer_addrs_one (src t:base_typ) (h:HS.mem) (b:buf_t src t{B.live h b}) (s:ME.vale_heap) : Lemma
(ME.buffer_addr #t (as_vale_buffer b) s + DV.length (get_downview b) < Vale.Def.Words_s.pow2_64) | let bounded_buffer_addrs_one src t h b s = FStar.Pervasives.reveal_opaque (`%addr_map_pred) addr_map_pred | {
"file_name": "vale/code/arch/x64/interop/Vale.AsLowStar.MemoryHelpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 105,
"end_line": 117,
"start_col": 0,
"start_line": 117
} | module Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.MemoryAdapters
open Vale.Interop.Base
module B = LowStar.Buffer
module UV = LowStar.BufferView.Up
module DV = LowStar.BufferView.Down
module ME = Vale.X64.Memory
module VSig = Vale.AsLowStar.ValeSig
module IX64 = Vale.Interop.X64
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fst.checked",
"Vale.X64.Stack_Sems.fst.checked",
"Vale.X64.Stack_i.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.Memory_Sems.fst.checked",
"Vale.X64.Memory.fst.checked",... | [
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
src: Vale.Arch.HeapTypes_s.base_typ ->
t: Vale.Arch.HeapTypes_s.base_typ ->
h: FStar.Monotonic.HyperStack.mem ->
b: Vale.Interop.Base.buf_t src t {LowStar.Monotonic.Buffer.live h b} ->
s: Vale.X64.Memory.vale_heap
-> FStar.Pervasives.Lemma
(ensures
Vale.X64.Memory.buffer_addr (Vale.X64.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapTypes_s.base_typ",
"FStar.Monotonic.HyperStack.mem",
"Vale.Interop.Base.buf_t",
"LowStar.Monotonic.Buffer.live",
"Vale.Interop.Types.base_typ_as_type",
"LowStar.Buffer.trivial_preorder",
"Vale.X64.Memory.vale_heap",
"FStar.Pervasives.reveal_opaque",
"Vale.Interop.Types.b8",
"Vale.De... | [] | true | false | true | false | false | let bounded_buffer_addrs_one src t h b s =
| FStar.Pervasives.reveal_opaque (`%addr_map_pred) addr_map_pred | false |
Vale.AsLowStar.MemoryHelpers.fst | Vale.AsLowStar.MemoryHelpers.same_immbuffer_same_upviews | val same_immbuffer_same_upviews (#src #bt:base_typ) (b:ibuf_t src bt) (h0 h1:HS.mem) : Lemma
(requires Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures (
let db = get_downview b in
DV.length_eq db;
let ub = UV.mk_buffer db (LSig.view_of_base_typ bt) in
Seq.equal (UV.as_seq h0 ub) (UV.as_seq h1 ub... | val same_immbuffer_same_upviews (#src #bt:base_typ) (b:ibuf_t src bt) (h0 h1:HS.mem) : Lemma
(requires Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures (
let db = get_downview b in
DV.length_eq db;
let ub = UV.mk_buffer db (LSig.view_of_base_typ bt) in
Seq.equal (UV.as_seq h0 ub) (UV.as_seq h1 ub... | let same_immbuffer_same_upviews #src #bt b h0 h1 =
let dv = get_downview b in
let s0 = DV.as_seq h0 dv in
let s1 = DV.as_seq h1 dv in
let aux (i:nat{i < DV.length dv}) : Lemma (Seq.index s0 i == Seq.index s1 i) =
DV.as_seq_sel h0 dv i;
DV.as_seq_sel h1 dv i;
DV.get_sel h0 dv i;
D... | {
"file_name": "vale/code/arch/x64/interop/Vale.AsLowStar.MemoryHelpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 172,
"start_col": 0,
"start_line": 160
} | module Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.MemoryAdapters
open Vale.Interop.Base
module B = LowStar.Buffer
module UV = LowStar.BufferView.Up
module DV = LowStar.BufferView.Down
module ME = Vale.X64.Memory
module VSig = Vale.AsLowStar.ValeSig
module IX64 = Vale.Interop.X64
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fst.checked",
"Vale.X64.Stack_Sems.fst.checked",
"Vale.X64.Stack_i.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.Memory_Sems.fst.checked",
"Vale.X64.Memory.fst.checked",... | [
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Vale.Interop.Base.ibuf_t src bt ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal (LowStar.Monotonic.Buffer.as_seq h0 b)
(LowStar.Monotonic.Buffer.as_seq h1 b))
(ensures
(let db = V... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapTypes_s.base_typ",
"Vale.Interop.Base.ibuf_t",
"FStar.Monotonic.HyperStack.mem",
"Vale.Lib.BufferViewHelpers.lemma_uv_equal",
"FStar.UInt8.t",
"Vale.Interop.Types.base_typ_as_type",
"Vale.AsLowStar.LowStarSig.view_of_base_typ",
"Prims.unit",
"LowStar.BufferView.Down.length_eq",
"FSt... | [] | false | false | true | false | false | let same_immbuffer_same_upviews #src #bt b h0 h1 =
| let dv = get_downview b in
let s0 = DV.as_seq h0 dv in
let s1 = DV.as_seq h1 dv in
let aux (i: nat{i < DV.length dv}) : Lemma (Seq.index s0 i == Seq.index s1 i) =
DV.as_seq_sel h0 dv i;
DV.as_seq_sel h1 dv i;
DV.get_sel h0 dv i;
DV.get_sel h1 dv i
in
Classical.forall_intro aux;
Seq.lemma_eq_intro s0 s1;
DV.leng... | false |
Vale.AsLowStar.MemoryHelpers.fst | Vale.AsLowStar.MemoryHelpers.core_create_lemma_taint_hyp | val core_create_lemma_taint_hyp
(#max_arity:nat)
(#arg_reg:IX64.arg_reg_relation max_arity)
(args:IX64.arg_list)
(h0:HS.mem{mem_roots_p h0 args})
: Lemma
(ensures (let va_s = LSig.create_initial_vale_state #max_arity #arg_reg args h0 in
LSig.taint_hyp args va_s)) | val core_create_lemma_taint_hyp
(#max_arity:nat)
(#arg_reg:IX64.arg_reg_relation max_arity)
(args:IX64.arg_list)
(h0:HS.mem{mem_roots_p h0 args})
: Lemma
(ensures (let va_s = LSig.create_initial_vale_state #max_arity #arg_reg args h0 in
LSig.taint_hyp args va_s)) | let core_create_lemma_taint_hyp
#max_arity
#arg_reg
(args:IX64.arg_list)
(h0:HS.mem{mem_roots_p h0 args})
: Lemma
(ensures (let va_s = LSig.create_initial_vale_state #max_arity #arg_reg args h0 in
LSig.taint_hyp args va_s))
=
FStar.Pervasives.reveal_opaque (`%ME.get_vale_heap... | {
"file_name": "vale/code/arch/x64/interop/Vale.AsLowStar.MemoryHelpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 90,
"start_col": 0,
"start_line": 65
} | module Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.MemoryAdapters
open Vale.Interop.Base
module B = LowStar.Buffer
module UV = LowStar.BufferView.Up
module DV = LowStar.BufferView.Down
module ME = Vale.X64.Memory
module VSig = Vale.AsLowStar.ValeSig
module IX64 = Vale.Interop.X64
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fst.checked",
"Vale.X64.Stack_Sems.fst.checked",
"Vale.X64.Stack_i.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.Memory_Sems.fst.checked",
"Vale.X64.Memory.fst.checked",... | [
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
args: Vale.Interop.X64.arg_list ->
h0: FStar.Monotonic.HyperStack.mem{Vale.Interop.Base.mem_roots_p h0 args}
-> FStar.Pervasives.Lemma
(ensures
(let va_s = Vale.AsLowStar.LowStarSig.create_initial_vale_state args h0 in
Vale.AsLowStar.LowStarSig.taint_hyp args va_s)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Vale.Interop.X64.arg_reg_relation",
"Vale.Interop.X64.arg_list",
"FStar.Monotonic.HyperStack.mem",
"Vale.Interop.Base.mem_roots_p",
"FStar.BigOps.big_and'_forall",
"Vale.Interop.Base.arg",
"Vale.AsLowStar.LowStarSig.taint_hyp_arg",
"Prims.unit",
"Prims._assert",
"Prims.l_Forall",
... | [] | false | false | true | false | false | let core_create_lemma_taint_hyp
#max_arity
#arg_reg
(args: IX64.arg_list)
(h0: HS.mem{mem_roots_p h0 args})
: Lemma
(ensures
(let va_s = LSig.create_initial_vale_state #max_arity #arg_reg args h0 in
LSig.taint_hyp args va_s)) =
| FStar.Pervasives.reveal_opaque (`%ME.get_vale_heap) ME.get_vale_heap;
let va_s = LSig.create_initial_vale_state #max_arity #arg_reg args h0 in
let taint_map = full_heap_taint va_s.VS.vs_heap in
let mem = ME.get_vale_heap va_s.VS.vs_heap in
let raw_taint = let open IX64 in mk_taint args IX64.init_taint in
ME.valid_memta... | false |
Vale.AsLowStar.MemoryHelpers.fst | Vale.AsLowStar.MemoryHelpers.buffer_as_seq_invert | val buffer_as_seq_invert (src t:base_typ) (h:HS.mem) (s:ME.vale_heap) (b:(buf_t src t){B.live h b}) : Lemma
(requires (
DV.length_eq (get_downview b);
Seq.equal
(LSig.nat_to_uint_seq_t t (ME.buffer_as_seq s (as_vale_buffer b)))
(UV.as_seq h (UV.mk_buffer (get_downview b) (LSig.view_of_base_typ t)))))
(e... | val buffer_as_seq_invert (src t:base_typ) (h:HS.mem) (s:ME.vale_heap) (b:(buf_t src t){B.live h b}) : Lemma
(requires (
DV.length_eq (get_downview b);
Seq.equal
(LSig.nat_to_uint_seq_t t (ME.buffer_as_seq s (as_vale_buffer b)))
(UV.as_seq h (UV.mk_buffer (get_downview b) (LSig.view_of_base_typ t)))))
(e... | let buffer_as_seq_invert src t h s b =
let db = get_downview b in
DV.length_eq db;
assert (Seq.equal
(ME.buffer_as_seq s (as_vale_buffer b))
(LSig.uint_to_nat_seq_t t (UV.as_seq h (UV.mk_buffer db (LSig.view_of_base_typ t))))) | {
"file_name": "vale/code/arch/x64/interop/Vale.AsLowStar.MemoryHelpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 111,
"start_col": 0,
"start_line": 106
} | module Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.MemoryAdapters
open Vale.Interop.Base
module B = LowStar.Buffer
module UV = LowStar.BufferView.Up
module DV = LowStar.BufferView.Down
module ME = Vale.X64.Memory
module VSig = Vale.AsLowStar.ValeSig
module IX64 = Vale.Interop.X64
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fst.checked",
"Vale.X64.Stack_Sems.fst.checked",
"Vale.X64.Stack_i.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.Memory_Sems.fst.checked",
"Vale.X64.Memory.fst.checked",... | [
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
src: Vale.Arch.HeapTypes_s.base_typ ->
t: Vale.Arch.HeapTypes_s.base_typ ->
h: FStar.Monotonic.HyperStack.mem ->
s: Vale.X64.Memory.vale_heap ->
b: Vale.Interop.Base.buf_t src t {LowStar.Monotonic.Buffer.live h b}
-> FStar.Pervasives.Lemma
(requires
(LowStar.BufferView.Down.length_e... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapTypes_s.base_typ",
"FStar.Monotonic.HyperStack.mem",
"Vale.X64.Memory.vale_heap",
"Vale.Interop.Base.buf_t",
"LowStar.Monotonic.Buffer.live",
"Vale.Interop.Types.base_typ_as_type",
"LowStar.Buffer.trivial_preorder",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.X64.Memory.base_typ_... | [] | true | false | true | false | false | let buffer_as_seq_invert src t h s b =
| let db = get_downview b in
DV.length_eq db;
assert (Seq.equal (ME.buffer_as_seq s (as_vale_buffer b))
(LSig.uint_to_nat_seq_t t (UV.as_seq h (UV.mk_buffer db (LSig.view_of_base_typ t))))) | false |
Steel.ST.OnRange.fst | Steel.ST.OnRange.on_range_join | val on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k) | val on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k) | let rec on_range_join
(#opened: _)
(p: (nat -> vprop))
(i j k: nat)
: STGhostT unit opened
(on_range p i j `star` on_range p j k)
(fun _ -> on_range p i k)
(decreases (if j >= i then j - i else 0))
= on_range_le p i j;
on_range_le p j k;
if i = j
then begin
rewrite (on_range p i j) emp;
... | {
"file_name": "lib/steel/Steel.ST.OnRange.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 76,
"start_col": 0,
"start_line": 58
} | module Steel.ST.OnRange
open Steel.ST.GenElim
let rec on_range
(p: (nat -> vprop))
(i j: nat)
: Tot vprop
(decreases (if j <= i then 0 else j - i))
= if j < i
then pure False
else if j = i
then emp
else p i `star` on_range p (i + 1) j
let on_range_le
p i j
= if i <= j
then noop ()
else begin
r... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.OnRange.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "St... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: Prims.nat -> Steel.Effect.Common.vprop) -> i: Prims.nat -> j: Prims.nat -> k: Prims.nat
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | Steel.ST.Effect.Ghost.STGhostT | [
""
] | [] | [
"Steel.Memory.inames",
"Prims.nat",
"Steel.Effect.Common.vprop",
"Prims.op_Equality",
"Steel.ST.Util.rewrite",
"Steel.ST.OnRange.on_range",
"Prims.unit",
"Steel.Effect.Common.emp",
"Prims.bool",
"Steel.Effect.Common.star",
"Prims.op_Addition",
"Steel.ST.OnRange.on_range_join",
"Steel.ST.OnRa... | [
"recursion"
] | false | true | false | false | false | let rec on_range_join (#opened: _) (p: (nat -> vprop)) (i j k: nat)
: STGhostT unit
opened
((on_range p i j) `star` (on_range p j k))
(fun _ -> on_range p i k)
(decreases (if j >= i then j - i else 0)) =
| on_range_le p i j;
on_range_le p j k;
if i = j
then
(rewrite (on_range p i j) emp;
rewrite (on_range p j k) (on_range p i k))
else
(rewrite (on_range p i j) ((p i) `star` (on_range p (i + 1) j));
on_range_join p (i + 1) j k;
rewrite ((p i) `star` (on_range p (i + 1) k)) (on_range p i k)) | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.as_payload_list | val as_payload_list (h: HS.mem) (d: dll 'a) : GTot (list 'a) | val as_payload_list (h: HS.mem) (d: dll 'a) : GTot (list 'a) | let as_payload_list (h:HS.mem) (d:dll 'a) : GTot (list 'a) =
g_node_vals h (as_list h d) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 90,
"start_col": 0,
"start_line": 89
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: FStar.Monotonic.HyperStack.mem -> d: DoublyLinkedListIface.dll 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"DoublyLinkedListIface.dll",
"DoublyLinkedListIface.g_node_vals",
"DoublyLinkedListIface.as_list",
"Prims.list"
] | [] | false | false | false | false | false | let as_payload_list (h: HS.mem) (d: dll 'a) : GTot (list 'a) =
| g_node_vals h (as_list h d) | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_at_head | val l_insert_at_head (l: list 'a) (x: 'a) : GTot (list 'a) | val l_insert_at_head (l: list 'a) (x: 'a) : GTot (list 'a) | let l_insert_at_head (l:list 'a) (x:'a) : GTot (list 'a) =
x :: l | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 182,
"start_col": 0,
"start_line": 181
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a -> x: 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.Cons"
] | [] | false | false | false | false | false | let l_insert_at_head (l: list 'a) (x: 'a) : GTot (list 'a) =
| x :: l | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_at_tail | val l_insert_at_tail (l: list 'a) (x: 'a) : GTot (list 'a) | val l_insert_at_tail (l: list 'a) (x: 'a) : GTot (list 'a) | let l_insert_at_tail (l:list 'a) (x:'a) : GTot (list 'a) =
L.snoc (l, x) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 185,
"start_col": 0,
"start_line": 184
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a -> x: 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.List.Tot.Base.snoc",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | false | false | let l_insert_at_tail (l: list 'a) (x: 'a) : GTot (list 'a) =
| L.snoc (l, x) | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_remove_tail | val l_remove_tail (l: list 'a {L.length l > 0}) : GTot (list 'a) | val l_remove_tail (l: list 'a {L.length l > 0}) : GTot (list 'a) | let l_remove_tail (l:list 'a{L.length l > 0}) : GTot (list 'a) =
let l', _ = L.unsnoc l in
l' | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 210,
"start_col": 0,
"start_line": 208
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a {FStar.List.Tot.Base.length l > 0} -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.unsnoc"
] | [] | false | false | false | false | false | let l_remove_tail (l: list 'a {L.length l > 0}) : GTot (list 'a) =
| let l', _ = L.unsnoc l in
l' | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_before' | val l_insert_before' (i: nat) (l: list 'a) (x: 'a) : GTot (list 'a) | val l_insert_before' (i: nat) (l: list 'a) (x: 'a) : GTot (list 'a) | let l_insert_before' (i:nat) (l:list 'a) (x:'a) : GTot (list 'a) =
let l1, l2 = L.splitAt i l in
l1 `L.append` (x :: l2) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 193,
"start_col": 0,
"start_line": 191
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.nat -> l: Prims.list 'a -> x: 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"Prims.list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | false | false | false | false | false | let l_insert_before' (i: nat) (l: list 'a) (x: 'a) : GTot (list 'a) =
| let l1, l2 = L.splitAt i l in
l1 `L.append` (x :: l2) | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_split_using | val l_split_using (l: list 'a) (x: 'a{x `L.memP` l}) : GTot (list 'a * list 'a) | val l_split_using (l: list 'a) (x: 'a{x `L.memP` l}) : GTot (list 'a * list 'a) | let l_split_using (l:list 'a) (x:'a{x `L.memP` l}) : GTot (list 'a * list 'a) =
L.split_using l x | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 225,
"start_col": 0,
"start_line": 224
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a -> x: 'a{FStar.List.Tot.Base.memP x l}
-> Prims.GTot (Prims.list 'a * Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.List.Tot.Base.memP",
"FStar.List.Tot.Properties.split_using",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let l_split_using (l: list 'a) (x: 'a{x `L.memP` l}) : GTot (list 'a * list 'a) =
| L.split_using l x | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_append | val l_append (l1 l2: list 'a) : GTot (list 'a) | val l_append (l1 l2: list 'a) : GTot (list 'a) | let l_append (l1 l2:list 'a) : GTot (list 'a) =
l1 `L.append` l2 | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 222,
"start_col": 0,
"start_line": 221
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l1: Prims.list 'a -> l2: Prims.list 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.List.Tot.Base.append"
] | [] | false | false | false | false | false | let l_append (l1 l2: list 'a) : GTot (list 'a) =
| l1 `L.append` l2 | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_split_using' | val l_split_using' (l: list 'a) (i: nat) : GTot (list 'a * list 'a) | val l_split_using' (l: list 'a) (i: nat) : GTot (list 'a * list 'a) | let l_split_using' (l:list 'a) (i:nat) : GTot (list 'a * list 'a) =
L.splitAt i l | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 228,
"start_col": 0,
"start_line": 227
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a -> i: Prims.nat -> Prims.GTot (Prims.list 'a * Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.nat",
"FStar.List.Tot.Base.splitAt",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let l_split_using' (l: list 'a) (i: nat) : GTot (list 'a * list 'a) =
| L.splitAt i l | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.loc_equiv | val loc_equiv : a: LowStar.Monotonic.Buffer.loc -> b: LowStar.Monotonic.Buffer.loc -> Prims.logical | let loc_equiv (a b:B.loc) =
B.loc_includes a b /\ B.loc_includes b a | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 233,
"start_col": 0,
"start_line": 232
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: LowStar.Monotonic.Buffer.loc -> b: LowStar.Monotonic.Buffer.loc -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_includes",
"Prims.logical"
] | [] | false | false | false | true | true | let loc_equiv (a b: B.loc) =
| B.loc_includes a b /\ B.loc_includes b a | false | |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.fp_strictly_disjoint_union | val fp_strictly_disjoint_union : l: LowStar.Monotonic.Buffer.loc ->
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc
-> Prims.logical | let fp_strictly_disjoint_union (l l1 l2:B.loc) =
l `loc_equiv` B.loc_union l1 l2 /\
l1 `B.loc_disjoint` l2 | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 287,
"start_col": 0,
"start_line": 285
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
l: LowStar.Monotonic.Buffer.loc ->
l1: LowStar.Monotonic.Buffer.loc ->
l2: LowStar.Monotonic.Buffer.loc
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"DoublyLinkedListIface.loc_equiv",
"LowStar.Monotonic.Buffer.loc_union",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Prims.logical"
] | [] | false | false | false | true | true | let fp_strictly_disjoint_union (l l1 l2: B.loc) =
| l `loc_equiv` (B.loc_union l1 l2) /\ l1 `B.loc_disjoint` l2 | false | |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.aux_fp_split_by_node | val aux_fp_split_by_node : h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem ->
d: DoublyLinkedListIface.dll 'a ->
n: DoublyLinkedListIface.node 'a
-> Prims.logical | let aux_fp_split_by_node (h0 h1:HS.mem) (d:dll 'a) (n:node 'a) =
fp_strictly_disjoint_union (fp_dll h0 d) (fp_dll h1 d) (fp_node n) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 68,
"end_line": 291,
"start_col": 0,
"start_line": 290
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem ->
d: DoublyLinkedListIface.dll 'a ->
n: DoublyLinkedListIface.node 'a
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"DoublyLinkedListIface.dll",
"DoublyLinkedListIface.node",
"DoublyLinkedListIface.fp_strictly_disjoint_union",
"DoublyLinkedListIface.fp_dll",
"DoublyLinkedListIface.fp_node",
"Prims.logical"
] | [] | false | false | false | true | true | let aux_fp_split_by_node (h0 h1: HS.mem) (d: dll 'a) (n: node 'a) =
| fp_strictly_disjoint_union (fp_dll h0 d) (fp_dll h1 d) (fp_node n) | false | |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_before | val l_insert_before (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) | val l_insert_before (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) | let l_insert_before (x0:'a) (l:list 'a{x0 `L.memP` l}) (x:'a) : GTot (list 'a) =
let l1, l2 = L.split_using l x0 in
l1 `L.append` (x :: l2) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 189,
"start_col": 0,
"start_line": 187
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x0: 'a -> l: Prims.list 'a {FStar.List.Tot.Base.memP x0 l} -> x: 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.List.Tot.Base.memP",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Properties.split_using"
] | [] | false | false | false | false | false | let l_insert_before (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) =
| let l1, l2 = L.split_using l x0 in
l1 `L.append` (x :: l2) | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_remove_head | val l_remove_head (l: list 'a {L.length l > 0}) : GTot (list 'a) | val l_remove_head (l: list 'a {L.length l > 0}) : GTot (list 'a) | let l_remove_head (l:list 'a{L.length l > 0}) : GTot (list 'a) =
match l with
| _ :: l' -> l' | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 206,
"start_col": 0,
"start_line": 204
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a {FStar.List.Tot.Base.length l > 0} -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length"
] | [] | false | false | false | false | false | let l_remove_head (l: list 'a {L.length l > 0}) : GTot (list 'a) =
| match l with | _ :: l' -> l' | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_after | val l_insert_after (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) | val l_insert_after (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) | let l_insert_after (x0:'a) (l:list 'a{x0 `L.memP` l}) (x:'a) : GTot (list 'a) =
let l1, x1 :: l2 = L.lemma_split_using l x0; L.split_using l x0 in
assert (x0 == x1);
l1 `L.append` (x0 :: (x :: l2)) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 198,
"start_col": 0,
"start_line": 195
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x0: 'a -> l: Prims.list 'a {FStar.List.Tot.Base.memP x0 l} -> x: 'a -> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"FStar.List.Tot.Base.memP",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Properties.split_using",
"FStar.List.Tot.Properties.lemma_split_using"
] | [] | false | false | false | false | false | let l_insert_after (x0: 'a) (l: list 'a {x0 `L.memP` l}) (x: 'a) : GTot (list 'a) =
| let l1, x1 :: l2 =
L.lemma_split_using l x0;
L.split_using l x0
in
assert (x0 == x1);
l1 `L.append` (x0 :: (x :: l2)) | false |
Vale.AsLowStar.MemoryHelpers.fst | Vale.AsLowStar.MemoryHelpers.down_up_buffer_read_reveal | val down_up_buffer_read_reveal (src:base_typ) (h:HS.mem) (s:ME.vale_heap) (b:(buf_t src src){B.live h b}) (i:nat{i < DV.length (get_downview b) / view_n src}) : Lemma
(requires (
DV.length_eq (get_downview b);
same_down_up_buffer_length src b;
Seq.equal
(LSig.nat_to_uint_seq_t src (ME.buffer_as_seq s (as... | val down_up_buffer_read_reveal (src:base_typ) (h:HS.mem) (s:ME.vale_heap) (b:(buf_t src src){B.live h b}) (i:nat{i < DV.length (get_downview b) / view_n src}) : Lemma
(requires (
DV.length_eq (get_downview b);
same_down_up_buffer_length src b;
Seq.equal
(LSig.nat_to_uint_seq_t src (ME.buffer_as_seq s (as... | let down_up_buffer_read_reveal src h s b i =
let db = get_downview b in
let n:pos = view_n src in
let up_view = (LSig.view_of_base_typ src) in
let ub = UV.mk_buffer db up_view in
same_down_up_buffer_length src b;
UV.length_eq ub;
UV.get_sel h ub i;
FStar.Math.Lemmas.lemma_mult_lt_right n i (DV.length db... | {
"file_name": "vale/code/arch/x64/interop/Vale.AsLowStar.MemoryHelpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 143,
"start_col": 0,
"start_line": 127
} | module Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.MemoryAdapters
open Vale.Interop.Base
module B = LowStar.Buffer
module UV = LowStar.BufferView.Up
module DV = LowStar.BufferView.Down
module ME = Vale.X64.Memory
module VSig = Vale.AsLowStar.ValeSig
module IX64 = Vale.Interop.X64
... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fst.checked",
"Vale.X64.Stack_Sems.fst.checked",
"Vale.X64.Stack_i.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.MemoryAdapters.fst.checked",
"Vale.X64.Memory_Sems.fst.checked",
"Vale.X64.Memory.fst.checked",... | [
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
src: Vale.Arch.HeapTypes_s.base_typ ->
h: FStar.Monotonic.HyperStack.mem ->
s: Vale.X64.Memory.vale_heap ->
b: Vale.Interop.Base.buf_t src src {LowStar.Monotonic.Buffer.live h b} ->
i:
Prims.nat
{ i <
LowStar.BufferView.Down.length (Vale.Interop.Types.get_downview b) /
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapTypes_s.base_typ",
"FStar.Monotonic.HyperStack.mem",
"Vale.X64.Memory.vale_heap",
"Vale.Interop.Base.buf_t",
"LowStar.Monotonic.Buffer.live",
"Vale.Interop.Types.base_typ_as_type",
"LowStar.Buffer.trivial_preorder",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division... | [] | false | false | true | false | false | let down_up_buffer_read_reveal src h s b i =
| let db = get_downview b in
let n:pos = view_n src in
let up_view = (LSig.view_of_base_typ src) in
let ub = UV.mk_buffer db up_view in
same_down_up_buffer_length src b;
UV.length_eq ub;
UV.get_sel h ub i;
FStar.Math.Lemmas.lemma_mult_lt_right n i (DV.length db / n);
FStar.Math.Lemmas.multiply_fractions (DV.length db) n;... | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_insert_after' | val l_insert_after' (i: nat) (l: list 'a {i < L.length l}) (x: 'a) : GTot (list 'a) | val l_insert_after' (i: nat) (l: list 'a {i < L.length l}) (x: 'a) : GTot (list 'a) | let l_insert_after' (i:nat) (l:list 'a{i < L.length l}) (x:'a) : GTot (list 'a) =
let l1, x1 :: l2 = L.lemma_splitAt_snd_length i l; L.splitAt i l in
l1 `L.append` ((L.index l i) :: (x :: l2)) | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 202,
"start_col": 0,
"start_line": 200
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.nat -> l: Prims.list 'a {i < FStar.List.Tot.Base.length l} -> x: 'a
-> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"Prims.list",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"FStar.List.Tot.Base.index",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt",
"Prims.unit",
"FStar.List.Tot.Base.lemma_splitAt_snd_length"
] | [] | false | false | false | false | false | let l_insert_after' (i: nat) (l: list 'a {i < L.length l}) (x: 'a) : GTot (list 'a) =
| let l1, x1 :: l2 =
L.lemma_splitAt_snd_length i l;
L.splitAt i l
in
l1 `L.append` ((L.index l i) :: (x :: l2)) | false |
MerkleTree.Low.VectorExtras.fst | MerkleTree.Low.VectorExtras.move_left | val move_left (#a: _) (b: B.buffer a) (dst src l: U32.t)
: HST.Stack unit
(requires fun h0 -> B.live h0 b /\ U32.v src + U32.v l <= B.length b /\ U32.v dst <= U32.v src
)
(ensures
fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\
(let b0 = B.as_seq h0 b in
... | val move_left (#a: _) (b: B.buffer a) (dst src l: U32.t)
: HST.Stack unit
(requires fun h0 -> B.live h0 b /\ U32.v src + U32.v l <= B.length b /\ U32.v dst <= U32.v src
)
(ensures
fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\
(let b0 = B.as_seq h0 b in
... | let move_left #a (b: B.buffer a) (dst src: U32.t) (l: U32.t): HST.Stack unit
(requires fun h0 ->
B.live h0 b /\
U32.v src + U32.v l <= B.length b /\
U32.v dst <= U32.v src)
(ensures fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\ (
let b0 = B.as_seq h0 b in
let b1 = B.as_seq h1 b in
... | {
"file_name": "src/MerkleTree.Low.VectorExtras.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 25,
"end_line": 108,
"start_col": 0,
"start_line": 26
} | module MerkleTree.Low.VectorExtras
module B = LowStar.Buffer
module S = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module U32 = FStar.UInt32
open LowStar.BufferOps
open Hacl.Hash.Lemmas
open FStar.Integers
open LowStar.Modifies
open LowStar.Regional
open LowStar.Vector
open LowStar.RVect... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.RVector.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Hacl.Hash.Lemmas.fst.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.RVector",
"short_module": "RV"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": false,
"full_module": "LowStar.RVector",
"short_module": null
},
{
"abbrev": false,
"full_module":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: LowStar.Buffer.buffer a -> dst: FStar.UInt32.t -> src: FStar.UInt32.t -> l: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt32.t",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThan",
"FStar.Monotonic.HyperStack.mem",
"Prims.op_Addition",
"FStar.Integers.op_Less_Equals",
"FStar.... | [] | false | true | false | false | false | let move_left #a (b: B.buffer a) (dst: U32.t) (src: U32.t) (l: U32.t)
: HST.Stack unit
(requires fun h0 -> B.live h0 b /\ U32.v src + U32.v l <= B.length b /\ U32.v dst <= U32.v src
)
(ensures
fun h0 _ h1 ->
B.(modifies (loc_buffer b) h0 h1) /\
(let b0 = B.as_seq h0 b i... | let h0 = HST.get () in
[@@ inline_let ]let inv (h: HS.mem) (i: nat) =
let b0 = B.as_seq h0 b in
let b1 = B.as_seq h b in
let src = U32.v src in
let dst = U32.v dst in
let l = U32.v l in
i <= l /\ B.(modifies (loc_buffer b) h0 h) /\
(S.slice b1 dst (dst + i)) `S.equal` (S.slice b0 src (src + i)) /\
(S.sl... | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_remove_mid' | val l_remove_mid' (l: list 'a {L.length l > 0}) (i: nat{i < L.length l}) : GTot (list 'a) | val l_remove_mid' (l: list 'a {L.length l > 0}) (i: nat{i < L.length l}) : GTot (list 'a) | let l_remove_mid' (l:list 'a{L.length l > 0}) (i:nat{i < L.length l}) : GTot (list 'a) =
let l1, x0 :: l2 = L.lemma_splitAt_snd_length i l; L.splitAt i l in
l1 `L.append` l2 | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 219,
"start_col": 0,
"start_line": 217
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
l: Prims.list 'a {FStar.List.Tot.Base.length l > 0} ->
i: Prims.nat{i < FStar.List.Tot.Base.length l}
-> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length",
"Prims.nat",
"Prims.op_LessThan",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt",
"Prims.unit",
"FStar.List.Tot.Base.lemma_splitAt_snd_length"
] | [] | false | false | false | false | false | let l_remove_mid' (l: list 'a {L.length l > 0}) (i: nat{i < L.length l}) : GTot (list 'a) =
| let l1, x0 :: l2 =
L.lemma_splitAt_snd_length i l;
L.splitAt i l
in
l1 `L.append` l2 | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.g_node_vals | val g_node_vals (h: HS.mem) (l: list (node 'a)) : GTot (list 'a) | val g_node_vals (h: HS.mem) (l: list (node 'a)) : GTot (list 'a) | let rec g_node_vals (h:HS.mem) (l:list (node 'a)) : GTot (list 'a) =
match l with
| [] -> []
| hd :: tl -> g_node_val h hd :: g_node_vals h tl | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 87,
"start_col": 0,
"start_line": 84
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | h: FStar.Monotonic.HyperStack.mem -> l: Prims.list (DoublyLinkedListIface.node 'a)
-> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.list",
"DoublyLinkedListIface.node",
"Prims.Nil",
"Prims.Cons",
"DoublyLinkedListIface.g_node_val",
"DoublyLinkedListIface.g_node_vals"
] | [
"recursion"
] | false | false | false | false | false | let rec g_node_vals (h: HS.mem) (l: list (node 'a)) : GTot (list 'a) =
| match l with
| [] -> []
| hd :: tl -> g_node_val h hd :: g_node_vals h tl | false |
DoublyLinkedListIface.fsti | DoublyLinkedListIface.l_remove_mid | val l_remove_mid (l: list 'a {L.length l > 0}) (x: 'a{x `L.memP` l}) : GTot (list 'a) | val l_remove_mid (l: list 'a {L.length l > 0}) (x: 'a{x `L.memP` l}) : GTot (list 'a) | let l_remove_mid (l:list 'a{L.length l > 0}) (x:'a {x `L.memP` l}) : GTot (list 'a) =
let l1, x0 :: l2 = L.lemma_split_using l x; L.split_using l x in
assert (x == x0);
l1 `L.append` l2 | {
"file_name": "examples/doublylinkedlist/DoublyLinkedListIface.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 215,
"start_col": 0,
"start_line": 212
} | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": fa... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list 'a {FStar.List.Tot.Base.length l > 0} -> x: 'a{FStar.List.Tot.Base.memP x l}
-> Prims.GTot (Prims.list 'a) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length",
"FStar.List.Tot.Base.memP",
"FStar.List.Tot.Base.append",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Properties.split_using",
"FStar.List.Tot.Properties.lemma_spl... | [] | false | false | false | false | false | let l_remove_mid (l: list 'a {L.length l > 0}) (x: 'a{x `L.memP` l}) : GTot (list 'a) =
| let l1, x0 :: l2 =
L.lemma_split_using l x;
L.split_using l x
in
assert (x == x0);
l1 `L.append` l2 | false |
FStar.OrdMap.fsti | FStar.OrdMap.cmp | val cmp : a: Prims.eqtype -> Type0 | let cmp (a:eqtype) = f:(a -> a -> Tot bool){total_order a f} | {
"file_name": "ulib/experimental/FStar.OrdMap.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.OrdSet.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.OrdMap.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.OrdSet",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.eqtype -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.bool",
"FStar.OrdMap.total_order"
] | [] | false | false | false | true | true | let cmp (a: eqtype) =
| f: (a -> a -> Tot bool){total_order a f} | false | |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_small_reg_name | val print_small_reg_name (r: reg_64) : string | val print_small_reg_name (r: reg_64) : string | let print_small_reg_name (r:reg_64) : string =
match r with
| 0 -> "al"
| 1 -> "bl"
| 2 -> "cl"
| 3 -> "dl"
| _ -> " !!! INVALID small operand !!! Expected al, bl, cl, or dl." | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 68,
"start_col": 0,
"start_line": 62
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Prims.int",
"Prims.string"
] | [] | false | false | false | true | false | let print_small_reg_name (r: reg_64) : string =
| match r with
| 0 -> "al"
| 1 -> "bl"
| 2 -> "cl"
| 3 -> "dl"
| _ -> " !!! INVALID small operand !!! Expected al, bl, cl, or dl." | false |
Hacl.HPKE.P256_CP256_SHA256.fsti | Hacl.HPKE.P256_CP256_SHA256.cs | val cs:S.ciphersuite | val cs:S.ciphersuite | let cs:S.ciphersuite = (DH.DH_P256, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | {
"file_name": "code/hpke/Hacl.HPKE.P256_CP256_SHA256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 96,
"end_line": 10,
"start_col": 0,
"start_line": 10
} | module Hacl.HPKE.P256_CP256_SHA256
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash | {
"checked_file": "/",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.chec... | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Spec.Agile.HPKE.ciphersuite | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.Mktuple4",
"Spec.Agile.DH.algorithm",
"Spec.Agile.HPKE.hash_algorithm",
"Spec.Agile.HPKE.aead",
"Spec.Hash.Definitions.hash_alg",
"Spec.Agile.DH.DH_P256",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.HPKE.Seal",
"Spec.Agile.AEAD.CHACHA20_POLY1305"
] | [] | false | false | false | true | false | let cs:S.ciphersuite =
| (DH.DH_P256, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_reg64 | val print_reg64 (r: reg_64) (p: printer) : string | val print_reg64 (r: reg_64) (p: printer) : string | let print_reg64 (r:reg_64) (p:printer) : string =
p.reg_prefix() ^ p.print_reg_name r | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 71,
"start_col": 0,
"start_line": 70
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_reg_name",
"Prims.string"
] | [] | false | false | false | true | false | let print_reg64 (r: reg_64) (p: printer) : string =
| p.reg_prefix () ^ p.print_reg_name r | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_reg32_name | val print_reg32_name (r: reg_64) : string | val print_reg32_name (r: reg_64) : string | let print_reg32_name (r:reg_64) : string =
match r with
| 0 -> "eax"
| 1 -> "ebx"
| 2 -> "ecx"
| 3 -> "edx"
| 4 -> "esi"
| 5 -> "edi"
| 6 -> "ebp"
| 7 -> "esp"
| _ -> print_reg_name r ^ "d" | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 60,
"start_col": 0,
"start_line": 50
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Prims.int",
"Prims.op_Hat",
"Vale.X64.Print_s.print_reg_name",
"Prims.string"
] | [] | false | false | false | true | false | let print_reg32_name (r: reg_64) : string =
| match r with
| 0 -> "eax"
| 1 -> "ebx"
| 2 -> "ecx"
| 3 -> "edx"
| 4 -> "esi"
| 5 -> "edi"
| 6 -> "ebp"
| 7 -> "esp"
| _ -> print_reg_name r ^ "d" | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_reg32 | val print_reg32 (r: reg_64) (p: printer) : string | val print_reg32 (r: reg_64) (p: printer) : string | let print_reg32 (r:reg_64) (p:printer) : string =
p.reg_prefix() ^ p.print_reg32_name r | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_reg32_name",
"Prims.string"
] | [] | false | false | false | true | false | let print_reg32 (r: reg_64) (p: printer) : string =
| p.reg_prefix () ^ p.print_reg32_name r | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_small_reg | val print_small_reg (r: reg_64) (p: printer) : string | val print_small_reg (r: reg_64) (p: printer) : string | let print_small_reg (r:reg_64) (p:printer) : string =
p.reg_prefix() ^ p.print_small_reg_name r | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 77,
"start_col": 0,
"start_line": 76
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_small_reg_name",
"Prims.string"
] | [] | false | false | false | true | false | let print_small_reg (r: reg_64) (p: printer) : string =
| p.reg_prefix () ^ p.print_small_reg_name r | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_xmm | val print_xmm (x: reg_xmm) (p: printer) : string | val print_xmm (x: reg_xmm) (p: printer) : string | let print_xmm (x:reg_xmm) (p:printer) : string =
p.reg_prefix () ^ "xmm" ^ string_of_int x | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 124,
"start_col": 0,
"start_line": 123
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Vale.X64.Machine_s.reg_xmm -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Prims.string_of_int",
"Prims.string"
] | [] | false | false | false | true | false | let print_xmm (x: reg_xmm) (p: printer) : string =
| p.reg_prefix () ^ "xmm" ^ string_of_int x | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_pair | val print_pair (dst src: string) (p: printer) : string | val print_pair (dst src: string) (p: printer) : string | let print_pair (dst src:string) (p:printer) : string =
let first, second = p.op_order dst src in
first ^ ", " ^ second | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 156,
"start_col": 0,
"start_line": 154
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | dst: Prims.string -> src: Prims.string -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Print_s.__proj__Mkprinter__item__op_order"
] | [] | false | false | false | true | false | let print_pair (dst src: string) (p: printer) : string =
| let first, second = p.op_order dst src in
first ^ ", " ^ second | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_imm8 | val print_imm8 (i: int) (p: printer) : string | val print_imm8 (i: int) (p: printer) : string | let print_imm8 (i:int) (p:printer) : string =
p.const i | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 121,
"start_col": 0,
"start_line": 120
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: Prims.int -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.X64.Print_s.printer",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Prims.string"
] | [] | false | false | false | true | false | let print_imm8 (i: int) (p: printer) : string =
| p.const i | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_proc | val print_proc (name: string) (code: code) (label: int) (p: printer) : FStar.All.ML int | val print_proc (name: string) (code: code) (label: int) (p: printer) : FStar.All.ML int | let print_proc (name:string) (code:code) (label:int) (p:printer) : FStar.All.ML int =
let proc = p.proc_name name in
let code_str, final_label = print_code code label p in
let ret = p.ret name in
print_string (proc ^ code_str ^ ret);
final_label | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 296,
"start_col": 0,
"start_line": 291
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
name: Prims.string ->
code: Vale.X64.Machine_Semantics_s.code ->
label: Prims.int ->
p: Vale.X64.Print_s.printer
-> FStar.All.ML Prims.int | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Vale.X64.Machine_Semantics_s.code",
"Prims.int",
"Vale.X64.Print_s.printer",
"Prims.unit",
"FStar.IO.print_string",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__ret",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Print_s.print_code",
"Vale.X64.Print_s.__proj__Mkprint... | [] | false | true | false | false | false | let print_proc (name: string) (code: code) (label: int) (p: printer) : FStar.All.ML int =
| let proc = p.proc_name name in
let code_str, final_label = print_code code label p in
let ret = p.ret name in
print_string (proc ^ code_str ^ ret);
final_label | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_header | val print_header : p: Vale.X64.Print_s.printer -> FStar.All.ML Prims.unit | let print_header (p:printer) =
print_string (p.header()) | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 289,
"start_col": 0,
"start_line": 288
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Vale.X64.Print_s.printer -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Vale.X64.Print_s.printer",
"FStar.IO.print_string",
"Vale.X64.Print_s.__proj__Mkprinter__item__header",
"Prims.unit"
] | [] | false | true | false | false | false | let print_header (p: printer) =
| print_string (p.header ()) | false | |
TwoLockQueue.fst | TwoLockQueue.dequeue | val dequeue (#a: _) (hdl: t a) : SteelT (option a) emp (fun _ -> emp) | val dequeue (#a: _) (hdl: t a) : SteelT (option a) emp (fun _ -> emp) | let dequeue (#a:_) (hdl:t a)
: SteelT (option a) emp (fun _ -> emp)
= // Blocks until it can acquire the head lock, corresponding to the dequeuer
Steel.SpinLock.acquire hdl.head.lock;
let v = open_exists () in
let hd = read_pt hdl.head.ptr in
// Executes the atomic dequeue, preserving the global que... | {
"file_name": "share/steel/examples/steel/TwoLockQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 12,
"end_line": 297,
"start_col": 0,
"start_line": 258
} | module TwoLockQueue
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.FractionalPermission
open Steel.Reference
open Steel.SpinLock
module L = FStar.List.Tot
module U = Steel.Utils
module Q = Queue
/// This module provides an implementation of Michael and Scott's two lock queue... | {
"checked_file": "/",
"dependencies": [
"Steel.Utils.fst.checked",
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"Queue.fsti.check... | [
{
"abbrev": true,
"full_module": "Queue",
"short_module": "Q"
},
{
"abbrev": true,
"full_module": "Steel.Utils",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.SpinLock"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | hdl: TwoLockQueue.t a -> Steel.Effect.SteelT (FStar.Pervasives.Native.option a) | Steel.Effect.SteelT | [] | [] | [
"TwoLockQueue.t",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.unit",
"Steel.SpinLock.release",
"TwoLockQueue.lock_inv",
"TwoLockQueue.__proj__Mkq_ptr__item__ptr",
"TwoLockQueue.__proj__Mkt__item__head",
"TwoLockQueue.__proj__Mkq_ptr__item__ghost",
"TwoLockQueue.__proj_... | [] | false | true | false | false | false | let dequeue (#a: _) (hdl: t a) : SteelT (option a) emp (fun _ -> emp) =
| Steel.SpinLock.acquire hdl.head.lock;
let v = open_exists () in
let hd = read_pt hdl.head.ptr in
let o = with_invariant hdl.inv (dequeue_core hdl hd) in
match o with
| None ->
rewrite_slprop (maybe_ghost_pts_to hdl.head.ghost hd o)
(ghost_pts_to hdl.head.ghost half hd)
(fun _ -> ());
intro_exists _ (fun v -... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_reg_name | val print_reg_name (r: reg_64) : string | val print_reg_name (r: reg_64) : string | let print_reg_name (r:reg_64) : string =
match r with
| 0 -> "rax"
| 1 -> "rbx"
| 2 -> "rcx"
| 3 -> "rdx"
| 4 -> "rsi"
| 5 -> "rdi"
| 6 -> "rbp"
| 7 -> "rsp"
| 8 -> "r8"
| 9 -> "r9"
| 10 -> "r10"
| 11 -> "r11"
| 12 -> "r12"
| 13 -> "r13"
| 14 -> "r14"
| 15 -> "r15" | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 48,
"start_col": 0,
"start_line": 31
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg_64 -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Prims.string"
] | [] | false | false | false | true | false | let print_reg_name (r: reg_64) : string =
| match r with
| 0 -> "rax"
| 1 -> "rbx"
| 2 -> "rcx"
| 3 -> "rdx"
| 4 -> "rsi"
| 5 -> "rdi"
| 6 -> "rbp"
| 7 -> "rsp"
| 8 -> "r8"
| 9 -> "r9"
| 10 -> "r10"
| 11 -> "r11"
| 12 -> "r12"
| 13 -> "r13"
| 14 -> "r14"
| 15 -> "r15" | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_footer | val print_footer : p: Vale.X64.Print_s.printer -> FStar.All.ML Prims.unit | let print_footer (p:printer) =
print_string (p.footer()) | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 299,
"start_col": 0,
"start_line": 298
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Vale.X64.Print_s.printer -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Vale.X64.Print_s.printer",
"FStar.IO.print_string",
"Vale.X64.Print_s.__proj__Mkprinter__item__footer",
"Prims.unit"
] | [] | false | true | false | false | false | let print_footer (p: printer) =
| print_string (p.footer ()) | false | |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_operand | val print_operand (o: operand64) (p: printer) : string | val print_operand (o: operand64) (p: printer) : string | let print_operand (o:operand64) (p:printer) : string =
match o with
| OConst n ->
if 0 <= n && n < pow2_64 then p.const n
else "!!! INVALID constant: " ^ string_of_int n ^ " !!!"
| OReg r -> print_reg64 r p
| OMem (m, _) | OStack (m, _) -> print_maddr m "qword" print_reg_int p | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 102,
"start_col": 0,
"start_line": 96
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_s.operand64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.nat64",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Vale.X64.Machine_s.pow2_64",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Prims.bool",
"Prims.op_Hat",
"Prims.string_of_int",
"Pri... | [] | false | false | false | true | false | let print_operand (o: operand64) (p: printer) : string =
| match o with
| OConst n ->
if 0 <= n && n < pow2_64 then p.const n else "!!! INVALID constant: " ^ string_of_int n ^ " !!!"
| OReg r -> print_reg64 r p
| OMem (m, _) | OStack (m, _) -> print_maddr m "qword" print_reg_int p | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_reg_int | val print_reg_int (r: reg) (p: printer) : string | val print_reg_int (r: reg) (p: printer) : string | let print_reg_int (r:reg) (p:printer) : string =
match r with
| Reg 0 r -> print_reg64 r p
| _ -> "!!! INVALID integer register !!!" | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 94,
"start_col": 0,
"start_line": 91
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.X64.Machine_s.reg -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.reg_id",
"Vale.X64.Print_s.print_reg64",
"Prims.string"
] | [] | false | false | false | true | false | let print_reg_int (r: reg) (p: printer) : string =
| match r with
| Reg 0 r -> print_reg64 r p
| _ -> "!!! INVALID integer register !!!" | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_maddr | val print_maddr (m: maddr) (ptr_type: string) (reg_printer: (reg -> printer -> string)) (p: printer)
: string | val print_maddr (m: maddr) (ptr_type: string) (reg_printer: (reg -> printer -> string)) (p: printer)
: string | let print_maddr (m:maddr) (ptr_type:string) (reg_printer:reg -> printer -> string) (p:printer) : string =
p.mem_prefix ptr_type ^
( match m with
| MConst n -> p.const n
| MReg r offset -> p.maddr (reg_printer r p) None (string_of_int offset)
| MIndex base scale index offset ->
p.maddr (reg_print... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 88,
"start_col": 0,
"start_line": 79
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: Vale.X64.Machine_s.maddr ->
ptr_type: Prims.string ->
reg_printer: (_: Vale.X64.Machine_s.reg -> _: Vale.X64.Print_s.printer -> Prims.string) ->
p: Vale.X64.Print_s.printer
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.maddr",
"Prims.string",
"Vale.X64.Machine_s.reg",
"Vale.X64.Print_s.printer",
"Prims.op_Hat",
"Vale.X64.Print_s.__proj__Mkprinter__item__mem_prefix",
"Prims.int",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Vale.X64.Print_s.__proj__Mkprinter__item__maddr",
"FStar.Pervas... | [] | false | false | false | true | false | let print_maddr (m: maddr) (ptr_type: string) (reg_printer: (reg -> printer -> string)) (p: printer)
: string =
| p.mem_prefix ptr_type ^
(match m with
| MConst n -> p.const n
| MReg r offset -> p.maddr (reg_printer r p) None (string_of_int offset)
| MIndex base scale index offset ->
p.maddr (reg_printer base p)
(Some (string_of_int scale, reg_printer index p))
(string_of_int offset)) | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.gcc_linux | val gcc_linux:printer | val gcc_linux:printer | let gcc_linux : printer =
let footer () : string = ".section .note.GNU-stack,\"\",%progbits\n" in
{gcc with footer} | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 379,
"start_col": 0,
"start_line": 377
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.X64.Print_s.printer | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Print_s.Mkprinter",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_reg_name",
"Vale.X64.Print_s.gcc",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_reg32_name",
"Vale.X64.Print_s.__proj__Mkprinter__item__print_small_reg_name",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Vale.... | [] | false | false | false | true | false | let gcc_linux:printer =
| let footer () : string = ".section .note.GNU-stack,\"\",%progbits\n" in
{ gcc with footer = footer } | false |
Hacl.Impl.SecretBox.fst | Hacl.Impl.SecretBox.get_len0 | val get_len0 (len: size_t) : Tot (r: size_t{v r <= 32 /\ v r == Spec.get_len0 (v len)}) | val get_len0 (len: size_t) : Tot (r: size_t{v r <= 32 /\ v r == Spec.get_len0 (v len)}) | let get_len0 (len:size_t) : Tot (r:size_t{v r <= 32 /\ v r == Spec.get_len0 (v len)}) =
if len <=. 32ul then len else 32ul | {
"file_name": "code/nacl-box/Hacl.Impl.SecretBox.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 48,
"start_col": 0,
"start_line": 47
} | module Hacl.Impl.SecretBox
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Salsa20
open Hacl.Poly1305_32
module ST = FStar.HyperStack.ST
module Spec = Spec.SecretBox
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 -... | {
"checked_file": "/",
"dependencies": [
"Spec.SecretBox.fst.checked",
"Spec.Salsa20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Poly1305_32.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.SecretBox",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | len: Lib.IntTypes.size_t
-> r:
Lib.IntTypes.size_t
{Lib.IntTypes.v r <= 32 /\ Lib.IntTypes.v r == Spec.SecretBox.get_len0 (Lib.IntTypes.v len)} | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_t",
"Lib.IntTypes.op_Less_Equals_Dot",
"Lib.IntTypes.U32",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_Gr... | [] | false | false | false | false | false | let get_len0 (len: size_t) : Tot (r: size_t{v r <= 32 /\ v r == Spec.get_len0 (v len)}) =
| if len <=. 32ul then len else 32ul | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_shift_operand | val print_shift_operand (o: operand64) (p: printer) : string | val print_shift_operand (o: operand64) (p: printer) : string | let print_shift_operand (o:operand64) (p:printer) : string =
match o with
| OConst n ->
if n < 64 then p.const n
else "!!! INVALID shift operand: " ^ string_of_int n ^ " is too large !!!"
| OReg rRcx -> print_small_reg (OReg?.r o) p
| _ -> "!!! INVALID shift operand !!! Expected constant or cl." | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 140,
"start_col": 0,
"start_line": 134
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_s.operand64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.nat64",
"Prims.op_LessThan",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Prims.bool",
"Prims.op_Hat",
"Prims.string_of_int",
"Prims.string",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Print_s.print_small_reg",
... | [] | false | false | false | true | false | let print_shift_operand (o: operand64) (p: printer) : string =
| match o with
| OConst n ->
if n < 64
then p.const n
else "!!! INVALID shift operand: " ^ string_of_int n ^ " is too large !!!"
| OReg rRcx -> print_small_reg (OReg?.r o) p
| _ -> "!!! INVALID shift operand !!! Expected constant or cl." | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_small_operand | val print_small_operand (o: operand64) (p: printer) : string | val print_small_operand (o: operand64) (p: printer) : string | let print_small_operand (o:operand64) (p:printer) : string =
match o with
| OConst n ->
if n < 64 then p.const n
else "!!! INVALID constant: " ^ string_of_int n ^ " !!!!"
| OReg r -> print_small_reg r p
| _ -> "!!! INVALID small operand !!! Expected al, bl, cl, or dl." | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 118,
"start_col": 0,
"start_line": 112
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_s.operand64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.nat64",
"Prims.op_LessThan",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Prims.bool",
"Prims.op_Hat",
"Prims.string_of_int",
"Prims.string",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Print_s.print_small_reg",
... | [] | false | false | false | true | false | let print_small_operand (o: operand64) (p: printer) : string =
| match o with
| OConst n -> if n < 64 then p.const n else "!!! INVALID constant: " ^ string_of_int n ^ " !!!!"
| OReg r -> print_small_reg r p
| _ -> "!!! INVALID small operand !!! Expected al, bl, cl, or dl." | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_mov128_op | val print_mov128_op (o: operand128) (p: printer) : string | val print_mov128_op (o: operand128) (p: printer) : string | let print_mov128_op (o:operand128) (p:printer) : string =
match o with
| OConst _ -> "!!! INVALID xmm constants not allowed !!!"
| OReg x -> print_xmm x p
| OMem (m, _) | OStack (m, _) -> print_maddr m "xmmword" print_reg_int p | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 130,
"start_col": 0,
"start_line": 126
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_s.operand128 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand128",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Print_s.print_xmm",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Print_s.print_maddr",
"Vale.X64.Print_s.print_reg_int",
"Prims.string"
] | [] | false | false | false | true | false | let print_mov128_op (o: operand128) (p: printer) : string =
| match o with
| OConst _ -> "!!! INVALID xmm constants not allowed !!!"
| OReg x -> print_xmm x p
| OMem (m, _) | OStack (m, _) -> print_maddr m "xmmword" print_reg_int p | false |
Pulse.Lib.SeqMatch.fsti | Pulse.Lib.SeqMatch.seq_map | val seq_map (#t1 #t2: Type) (f: (t1 -> t2)) (s: Seq.seq t1) : Tot (Seq.seq t2) | val seq_map (#t1 #t2: Type) (f: (t1 -> t2)) (s: Seq.seq t1) : Tot (Seq.seq t2) | let seq_map (#t1 #t2: Type) (f: t1 -> t2) (s: Seq.seq t1) : Tot (Seq.seq t2) =
Seq.init (Seq.length s) (fun i -> f (Seq.index s i)) | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.SeqMatch.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 54,
"end_line": 337,
"start_col": 0,
"start_line": 336
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Stick",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: t1 -> t2) -> s: FStar.Seq.Base.seq t1 -> FStar.Seq.Base.seq t2 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Seq.Base.length",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index"
] | [] | false | false | false | true | false | let seq_map (#t1 #t2: Type) (f: (t1 -> t2)) (s: Seq.seq t1) : Tot (Seq.seq t2) =
| Seq.init (Seq.length s) (fun i -> f (Seq.index s i)) | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.cmp_not | val cmp_not (o: ocmp) : ocmp | val cmp_not (o: ocmp) : ocmp | let cmp_not(o:ocmp) : ocmp =
match o with
| OEq o1 o2 -> ONe o1 o2
| ONe o1 o2 -> OEq o1 o2
| OLe o1 o2 -> OGt o1 o2
| OGe o1 o2 -> OLt o1 o2
| OLt o1 o2 -> OGe o1 o2
| OGt o1 o2 -> OLe o1 o2 | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 149,
"start_col": 0,
"start_line": 142
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_Semantics_s.ocmp -> Vale.X64.Machine_Semantics_s.ocmp | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_Semantics_s.ocmp",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"Vale.X64.Bytes_Code_s.ONe",
"Vale.X64.Bytes_... | [] | false | false | false | true | false | let cmp_not (o: ocmp) : ocmp =
| match o with
| OEq o1 o2 -> ONe o1 o2
| ONe o1 o2 -> OEq o1 o2
| OLe o1 o2 -> OGt o1 o2
| OGe o1 o2 -> OLt o1 o2
| OLt o1 o2 -> OGe o1 o2
| OGt o1 o2 -> OLe o1 o2 | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_operand32 | val print_operand32 (o: operand64) (p: printer) : string | val print_operand32 (o: operand64) (p: printer) : string | let print_operand32 (o:operand64) (p:printer) : string =
match o with
| OConst n ->
if 0 <= n && n < pow2_32 then p.const n
else "!!! INVALID constant: " ^ string_of_int n ^ " !!!"
| OReg r -> print_reg32 r p
| OMem (m, _) | OStack (m, _) -> print_maddr m "dword" print_reg_int p | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 110,
"start_col": 0,
"start_line": 104
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | o: Vale.X64.Machine_s.operand64 -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.nat64",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Vale.X64.Machine_s.pow2_32",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Prims.bool",
"Prims.op_Hat",
"Prims.string_of_int",
"Pri... | [] | false | false | false | true | false | let print_operand32 (o: operand64) (p: printer) : string =
| match o with
| OConst n ->
if 0 <= n && n < pow2_32 then p.const n else "!!! INVALID constant: " ^ string_of_int n ^ " !!!"
| OReg r -> print_reg32 r p
| OMem (m, _) | OStack (m, _) -> print_maddr m "dword" print_reg_int p | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_instr | val print_instr (ip: instr_print) (p: printer) : string | val print_instr (ip: instr_print) (p: printer) : string | let print_instr (ip:instr_print) (p:printer) : string =
let Print name kind oprs = ip in
let (suffix, oprs) =
match kind with
| POpcode -> (false, oprs)
| PSuffix -> (true, oprs)
| PrintPSha256rnds2 ->
(false, (if p.sha256rnds2_explicit_xmm0 () then oprs @ [PXmm (OReg 0)] else oprs))
in
... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 199,
"start_col": 0,
"start_line": 158
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ip: Vale.X64.Instruction_s.instr_print -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Instruction_s.instr_print",
"Vale.X64.Print_s.printer",
"Prims.string",
"Vale.X64.Instruction_s.instr_print_kind",
"Prims.list",
"Vale.X64.Instruction_s.instr_print_operand",
"Prims.bool",
"Prims.op_Hat",
"Vale.X64.Print_s.print_pair",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Print_s.... | [] | false | false | false | true | false | let print_instr (ip: instr_print) (p: printer) : string =
| let Print name kind oprs = ip in
let suffix, oprs =
match kind with
| POpcode -> (false, oprs)
| PSuffix -> (true, oprs)
| PrintPSha256rnds2 ->
(false, (if p.sha256rnds2_explicit_xmm0 () then oprs @ [PXmm (OReg 0)] else oprs))
in
let rec get_operands (oprs: list instr_print_operand) : list operand64 =
mat... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_ins | val print_ins (ins: ins) (p: printer) : string | val print_ins (ins: ins) (p: printer) : string | let print_ins (ins:ins) (p:printer) : string =
let print_pair (dst src:string) = print_pair dst src p in
let print_op_pair (dst:operand64) (src:operand64) (print_dst:operand64 -> printer -> string) (print_src:operand64 -> printer -> string) =
print_pair (print_dst dst p) (print_src src p)
in
let print_ops (... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 98,
"end_line": 240,
"start_col": 0,
"start_line": 201
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ins: Vale.X64.Machine_Semantics_s.ins -> p: Vale.X64.Print_s.printer -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Print_s.printer",
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.flag_havoc",
"Vale.X64.Instruction_s.instr_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__... | [] | false | false | false | true | false | let print_ins (ins: ins) (p: printer) : string =
| let print_pair (dst src: string) = print_pair dst src p in
let print_op_pair (dst src: operand64) (print_dst print_src: (operand64 -> printer -> string)) =
print_pair (print_dst dst p) (print_src src p)
in
let print_ops (dst src: operand64) = print_op_pair dst src print_operand print_operand in
let print_shift (dst a... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_code | val print_code (c: code) (n: int) (p: printer) : string & int | val print_code (c: code) (n: int) (p: printer) : string & int | let rec print_block (b:codes) (n:int) (p:printer) : string & int =
match b with
| Nil -> ("", n)
| Ins (Instr _ _ (AnnotateSpace _)) :: tail -> print_block tail n p
| Ins (Instr _ _ (AnnotateGhost _)) :: tail -> print_block tail n p
| head :: tail ->
let (head_str, n') = print_code head n p in
let (re... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 286,
"start_col": 0,
"start_line": 255
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: Vale.X64.Machine_Semantics_s.code -> n: Prims.int -> p: Vale.X64.Print_s.printer
-> Prims.string * Prims.int | Prims.Tot | [
"total"
] | [
"print_block",
"print_code"
] | [
"Vale.X64.Machine_Semantics_s.code",
"Prims.int",
"Vale.X64.Print_s.printer",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"FStar.Pervasives.Native.Mktuple2",
"Prims.string",
"Prims.op_Hat",
"Vale.X64.Print_s.print_ins",
"Prims.list",
"Vale.X64.Machine_... | [
"mutual recursion"
] | false | false | false | true | false | let rec print_code (c: code) (n: int) (p: printer) : string & int =
| match c with
| Ins ins -> (print_ins ins p ^ "\n", n)
| Block b -> print_block b n p
| IfElse cond true_code false_code ->
let n1 = n in
let n2 = n + 1 in
let cmp = print_cmp (cmp_not cond) n1 p in
let true_str, n' = print_code true_code (n + 2) p in
let jmp = " jmp L" ^ string_of_int n2 ^ "\n" in
let labe... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.gcc | val gcc:printer | val gcc:printer | let gcc : printer =
let reg_prefix unit = "%" in
let mem_prefix (ptr_type:string) = "" in
let maddr (base:string) (adj:option(string & string)) (offset:string) =
match adj with
| None -> offset ^ "(" ^ base ^ ")"
| Some (scale, index) -> offset ^ " (" ^ base ^ ", " ^ scale ^ ", " ^ index ^ ")"
in
... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 374,
"start_col": 0,
"start_line": 337
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.X64.Print_s.printer | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Print_s.Mkprinter",
"Vale.X64.Print_s.print_reg_name",
"Vale.X64.Print_s.print_reg32_name",
"Vale.X64.Print_s.print_small_reg_name",
"Prims.unit",
"Prims.bool",
"Prims.string",
"Prims.op_Hat",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"Vale.X... | [] | false | false | false | true | false | let gcc:printer =
| let reg_prefix unit = "%" in
let mem_prefix (ptr_type: string) = "" in
let maddr (base: string) (adj: option (string & string)) (offset: string) =
match adj with
| None -> offset ^ "(" ^ base ^ ")"
| Some (scale, index) -> offset ^ " (" ^ base ^ ", " ^ scale ^ ", " ^ index ^ ")"
in
let const (n: int) = "$" ^ stri... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_cmp | val print_cmp (c: ocmp) (counter: int) (p: printer) : string | val print_cmp (c: ocmp) (counter: int) (p: printer) : string | let print_cmp (c:ocmp) (counter:int) (p:printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.op_order (print_operand o1 p) (print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> print_ops o1 o2 ^ " je " ^ "L" ^ string_o... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 253,
"start_col": 0,
"start_line": 242
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | c: Vale.X64.Machine_Semantics_s.ocmp -> counter: Prims.int -> p: Vale.X64.Print_s.printer
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_Semantics_s.ocmp",
"Prims.int",
"Vale.X64.Print_s.printer",
"Vale.X64.Machine_s.operand64",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_BarBar",
"Vale.X64.Machine_s.uu___is_OMem",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.uu___is_OStack",
"P... | [] | false | false | false | true | false | let print_cmp (c: ocmp) (counter: int) (p: printer) : string =
| let print_ops (o1 o2: operand64) : string =
let first, second = p.op_order (print_operand o1 p) (print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ "\n"
| ONe o1 o2 -> print_ops o1 o2 ^ " jne " ^ "L" ^ string_of_in... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.masm | val masm:printer | val masm:printer | let masm : printer =
let reg_prefix unit = "" in
let mem_prefix (ptr_type:string) = ptr_type ^ " ptr " in
let maddr (base:string) (adj:option(string & string)) (offset:string) =
match adj with
| None -> "[" ^ base ^ " + " ^ offset ^ "]"
| Some (scale, index) -> "[" ^ base ^ " + " ^ scale ^ " * " ^ ind... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 335,
"start_col": 0,
"start_line": 303
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Vale.X64.Print_s.printer | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Print_s.Mkprinter",
"Vale.X64.Print_s.print_reg_name",
"Vale.X64.Print_s.print_reg32_name",
"Vale.X64.Print_s.print_small_reg_name",
"Prims.unit",
"Prims.bool",
"Prims.string",
"Prims.op_Hat",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"Vale.X... | [] | false | false | false | true | false | let masm:printer =
| let reg_prefix unit = "" in
let mem_prefix (ptr_type: string) = ptr_type ^ " ptr " in
let maddr (base: string) (adj: option (string & string)) (offset: string) =
match adj with
| None -> "[" ^ base ^ " + " ^ offset ^ "]"
| Some (scale, index) -> "[" ^ base ^ " + " ^ scale ^ " * " ^ index ^ " + " ^ offset ^ "]"
in... | false |
Vale.X64.Print_s.fst | Vale.X64.Print_s.print_block | val print_block (b: codes) (n: int) (p: printer) : string & int | val print_block (b: codes) (n: int) (p: printer) : string & int | let rec print_block (b:codes) (n:int) (p:printer) : string & int =
match b with
| Nil -> ("", n)
| Ins (Instr _ _ (AnnotateSpace _)) :: tail -> print_block tail n p
| Ins (Instr _ _ (AnnotateGhost _)) :: tail -> print_block tail n p
| head :: tail ->
let (head_str, n') = print_code head n p in
let (re... | {
"file_name": "vale/specs/hardware/Vale.X64.Print_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 286,
"start_col": 0,
"start_line": 255
} | module Vale.X64.Print_s
open FStar.Mul
open FStar.List.Tot
// Trusted code for producing assembly code
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open FStar.IO
noeq type printer = {
print_reg_name: reg_64 -> string;
print_reg32_name: reg_64 ->... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
... | [
{
"abbrev": false,
"full_module": "FStar.UInt64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: Vale.X64.Machine_Semantics_s.codes -> n: Prims.int -> p: Vale.X64.Print_s.printer
-> Prims.string * Prims.int | Prims.Tot | [
"total"
] | [
"print_block",
"print_code"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.int",
"Vale.X64.Print_s.printer",
"FStar.Pervasives.Native.Mktuple2",
"Prims.string",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s... | [
"mutual recursion"
] | false | false | false | true | false | let rec print_block (b: codes) (n: int) (p: printer) : string & int =
| match b with
| Nil -> ("", n)
| Ins (Instr _ _ (AnnotateSpace _)) :: tail -> print_block tail n p
| Ins (Instr _ _ (AnnotateGhost _)) :: tail -> print_block tail n p
| head :: tail ->
let head_str, n' = print_code head n p in
let rest, n'' = print_block tail n' p in
(head_str ^ rest, n'') | false |
Pulse.Lib.SeqMatch.fsti | Pulse.Lib.SeqMatch.item_match_option | val item_match_option (#t1 #t2: Type) (p: (t1 -> t2 -> vprop)) (x1: t1) (x2: option t2) : Tot vprop | val item_match_option (#t1 #t2: Type) (p: (t1 -> t2 -> vprop)) (x1: t1) (x2: option t2) : Tot vprop | let item_match_option
(#t1 #t2: Type)
(p: t1 -> t2 -> vprop)
(x1: t1)
(x2: option t2)
: Tot vprop
= match x2 with
| None -> emp
| Some x2' -> p x1 x2' | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.SeqMatch.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 347,
"start_col": 0,
"start_line": 339
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Stick",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: t1 -> _: t2 -> Pulse.Lib.Core.vprop) -> x1: t1 -> x2: FStar.Pervasives.Native.option t2
-> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"Pulse.Lib.Core.vprop",
"FStar.Pervasives.Native.option",
"Pulse.Lib.Core.emp"
] | [] | false | false | false | true | false | let item_match_option (#t1 #t2: Type) (p: (t1 -> t2 -> vprop)) (x1: t1) (x2: option t2) : Tot vprop =
| match x2 with
| None -> emp
| Some x2' -> p x1 x2' | false |
Pulse.Lib.SeqMatch.fsti | Pulse.Lib.SeqMatch.list_cons_precedes | val list_cons_precedes (#t: Type) (a: t) (q: list t)
: Lemma ((a << a :: q) /\ (q << a :: q)) [SMTPat (a :: q)] | val list_cons_precedes (#t: Type) (a: t) (q: list t)
: Lemma ((a << a :: q) /\ (q << a :: q)) [SMTPat (a :: q)] | let list_cons_precedes
(#t: Type)
(a: t)
(q: list t)
: Lemma
((a << a :: q) /\ (q << a :: q))
[SMTPat (a :: q)]
= assert (List.Tot.hd (a :: q) << (a :: q));
assert (List.Tot.tl (a :: q) << (a :: q)) | {
"file_name": "share/steel/examples/pulse/lib/Pulse.Lib.SeqMatch.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 43,
"end_line": 67,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Stick.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_f... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Stick",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: t -> q: Prims.list t
-> FStar.Pervasives.Lemma (ensures a << a :: q /\ q << a :: q) [SMTPat (a :: q)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims._assert",
"Prims.precedes",
"FStar.List.Tot.Base.tl",
"Prims.Cons",
"Prims.unit",
"FStar.List.Tot.Base.hd",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let list_cons_precedes (#t: Type) (a: t) (q: list t)
: Lemma ((a << a :: q) /\ (q << a :: q)) [SMTPat (a :: q)] =
| assert (List.Tot.hd (a :: q) << (a :: q));
assert (List.Tot.tl (a :: q) << (a :: q)) | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr | val bn_sqr: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen -> lbignum t (aLen + aLen) | val bn_sqr: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen -> lbignum t (aLen + aLen) | let bn_sqr #t #aLen a =
let res = create (aLen + aLen) (uint #t 0) in
let res = repeati aLen (bn_sqr_f a) res in
let c, res = Hacl.Spec.Bignum.Addition.bn_add res res in
let tmp = bn_sqr_diag a in
let c, res = Hacl.Spec.Bignum.Addition.bn_add res tmp in
res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 64,
"start_col": 0,
"start_line": 58
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add",
"H... | [] | false | false | false | false | false | let bn_sqr #t #aLen a =
| let res = create (aLen + aLen) (uint #t 0) in
let res = repeati aLen (bn_sqr_f a) res in
let c, res = Hacl.Spec.Bignum.Addition.bn_add res res in
let tmp = bn_sqr_diag a in
let c, res = Hacl.Spec.Bignum.Addition.bn_add res tmp in
res | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag | val bn_sqr_diag:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen ->
lbignum t (aLen + aLen) | val bn_sqr_diag:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen ->
lbignum t (aLen + aLen) | let bn_sqr_diag #t #aLen a =
let acc0 = create (aLen + aLen) (uint #t 0) in
repeati aLen (bn_sqr_diag_f a) acc0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 41,
"start_col": 0,
"start_line": 39
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.LoopCombinators.repeati",
"Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f",
"Lib.Sequence.lseq",
"Hacl.Sp... | [] | false | false | false | false | false | let bn_sqr_diag #t #aLen a =
| let acc0 = create (aLen + aLen) (uint #t 0) in
repeati aLen (bn_sqr_diag_f a) acc0 | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_f | val bn_sqr_f:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> j:nat{j < aLen}
-> acc:lbignum t (aLen + aLen) ->
lbignum t (aLen + aLen) | val bn_sqr_f:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> j:nat{j < aLen}
-> acc:lbignum t (aLen + aLen) ->
lbignum t (aLen + aLen) | let bn_sqr_f #t #aLen a j acc =
let c, acc = SM.bn_mul1_lshift_add (sub a 0 j) a.[j] j acc in
acc.[j + j] <- c | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 54,
"start_col": 0,
"start_line": 52
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
j: Prims.nat{j < aLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen)
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.op_String_Assignme... | [] | false | false | false | false | false | let bn_sqr_f #t #aLen a j acc =
| let c, acc = SM.bn_mul1_lshift_add (sub a 0 j) a.[ j ] j acc in
acc.[ j + j ] <- c | false |
Hacl.Impl.SecretBox.fst | Hacl.Impl.SecretBox.secretbox_init | val secretbox_init:
xkeys:lbuffer uint8 96ul
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul ->
Stack unit
(requires fun h ->
live h xkeys /\ live h k /\ live h n /\
disjoint k xkeys /\ disjoint n xkeys)
(ensures fun h0 _ h1 ->
modifies (loc xkeys) h0 h1 /\
(let xkeys = as_seq h1 xkeys in... | val secretbox_init:
xkeys:lbuffer uint8 96ul
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul ->
Stack unit
(requires fun h ->
live h xkeys /\ live h k /\ live h n /\
disjoint k xkeys /\ disjoint n xkeys)
(ensures fun h0 _ h1 ->
modifies (loc xkeys) h0 h1 /\
(let xkeys = as_seq h1 xkeys in... | let secretbox_init xkeys k n =
let h0 = ST.get() in
let subkey = sub xkeys 0ul 32ul in
let aekey = sub xkeys 32ul 64ul in
let n0 = sub n 0ul 16ul in
let n1 = sub n 16ul 8ul in
hsalsa20 subkey k n0;
salsa20_key_block0 aekey subkey n1 | {
"file_name": "code/nacl-box/Hacl.Impl.SecretBox.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 43,
"start_col": 0,
"start_line": 36
} | module Hacl.Impl.SecretBox
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Salsa20
open Hacl.Poly1305_32
module ST = FStar.HyperStack.ST
module Spec = Spec.SecretBox
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 -... | {
"checked_file": "/",
"dependencies": [
"Spec.SecretBox.fst.checked",
"Spec.Salsa20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Poly1305_32.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.SecretBox",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
xkeys: Lib.Buffer.lbuffer Lib.IntTypes.uint8 96ul ->
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Salsa20.salsa20_key_block0",
"Prims.unit",
"Hacl.Salsa20.hsalsa20",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",... | [] | false | true | false | false | false | let secretbox_init xkeys k n =
| let h0 = ST.get () in
let subkey = sub xkeys 0ul 32ul in
let aekey = sub xkeys 32ul 64ul in
let n0 = sub n 0ul 16ul in
let n1 = sub n 16ul 8ul in
hsalsa20 subkey k n0;
salsa20_key_block0 aekey subkey n1 | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f | val bn_sqr_diag_f:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i < aLen}
-> acc:lbignum t (aLen + aLen) ->
lbignum t (aLen + aLen) | val bn_sqr_diag_f:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i < aLen}
-> acc:lbignum t (aLen + aLen) ->
lbignum t (aLen + aLen) | let bn_sqr_diag_f #t #aLen a i acc =
let (hi, lo) = mul_wide a.[i] a.[i] in
let acc = acc.[2 * i] <- lo in
let acc = acc.[2 * i + 1] <- hi in
acc | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 30,
"start_col": 0,
"start_line": 26
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.nat{i < aLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen)
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.lseq",
"Prims.l_... | [] | false | false | false | false | false | let bn_sqr_diag_f #t #aLen a i acc =
| let hi, lo = mul_wide a.[ i ] a.[ i ] in
let acc = acc.[ 2 * i ] <- lo in
let acc = acc.[ 2 * i + 1 ] <- hi in
acc | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_tail | val bn_sqr_tail:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati k (bn_sqr_f a) acc0 in
(forall (i:nat{k + k < i /\ i < aLen + aLen}). Seq.index acc i == ... | val bn_sqr_tail:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati k (bn_sqr_f a) acc0 in
(forall (i:nat{k + k < i /\ i < aLen + aLen}). Seq.index acc i == ... | let bn_sqr_tail #t #aLen a k =
let _ = bn_sqr_inductive a k in () | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 294,
"start_col": 0,
"start_line": 293
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> k: Prims.nat{k <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Sequence.create (aLen + aLen) (Lib.IntTypes.uint 0) in
let acc = Lib.LoopCombinators.repeati k (Hacl.Spec.Bignum.Squaring.bn_sqr_f a) acc0 in
forall (i: Prims.nat{k + ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Hacl.Spec.Bignum.Squaring.bn_sqr_inductive",
"Prims.unit"
] | [] | true | false | true | false | false | let bn_sqr_tail #t #aLen a k =
| let _ = bn_sqr_inductive a k in
() | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_lemma | val bn_sqr_diag_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
(forall (i:nat{i < k}).
let (hi, lo) = mul_wide a.[i... | val bn_sqr_diag_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
(forall (i:nat{i < k}).
let (hi, lo) = mul_wide a.[i... | let bn_sqr_diag_lemma #t #aLen a k =
let _ = bn_sqr_diag_inductive a k in () | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 155,
"start_col": 0,
"start_line": 154
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> k: Prims.nat{k <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Sequence.create (aLen + aLen) (Lib.IntTypes.uint 0) in
let acc = Lib.LoopCombinators.repeati k (Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f a) acc0 in
(forall (i: Prims.na... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Hacl.Spec.Bignum.Squaring.bn_sqr_diag_inductive",
"Prims.unit"
] | [] | true | false | true | false | false | let bn_sqr_diag_lemma #t #aLen a k =
| let _ = bn_sqr_diag_inductive a k in
() | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_lemma | val bn_sqr_lemma: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen ->
Lemma (bn_sqr a == SM.bn_mul a a /\ bn_v (bn_sqr a) == bn_v a * bn_v a) | val bn_sqr_lemma: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen ->
Lemma (bn_sqr a == SM.bn_mul a a /\ bn_v (bn_sqr a) == bn_v a * bn_v a) | let bn_sqr_lemma #t #aLen a =
let res = bn_sqr a in
bn_sqr_lemma_eval a;
assert (bn_v res == bn_v a * bn_v a);
let res' = SM.bn_mul a a in
SM.bn_mul_lemma a a;
assert (bn_v res' == bn_v a * bn_v a);
bn_eval_inj (aLen + aLen) res res';
assert (bn_sqr a == SM.bn_mul a a) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 424,
"start_col": 0,
"start_line": 416
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Squaring.bn_sqr a == Hacl.Spec.Bignum.Multiplication.bn_mul a a /\
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Squaring.bn_sqr a) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.D... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Bignum.Squaring.bn_sqr",
"Hacl.Spec.Bignum.Multiplication.bn_m... | [] | true | false | true | false | false | let bn_sqr_lemma #t #aLen a =
| let res = bn_sqr a in
bn_sqr_lemma_eval a;
assert (bn_v res == bn_v a * bn_v a);
let res' = SM.bn_mul a a in
SM.bn_mul_lemma a a;
assert (bn_v res' == bn_v a * bn_v a);
bn_eval_inj (aLen + aLen) res res';
assert (bn_sqr a == SM.bn_mul a a) | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_lemma_eval | val bn_sqr_lemma_eval: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen ->
Lemma (bn_v (bn_sqr a) == bn_v a * bn_v a) | val bn_sqr_lemma_eval: #t:limb_t -> #aLen:size_nat{aLen + aLen <= max_size_t} -> a:lbignum t aLen ->
Lemma (bn_v (bn_sqr a) == bn_v a * bn_v a) | let bn_sqr_lemma_eval #t #aLen a =
let pbits = bits t in
let resLen = aLen + aLen in
let res0 = create (aLen + aLen) (uint #t 0) in
let res1 = repeati aLen (bn_sqr_f a) res0 in
let c0, res2 = Hacl.Spec.Bignum.Addition.bn_add res1 res1 in
Hacl.Spec.Bignum.Addition.bn_add_lemma res1 res1;
let tmp = bn_sqr_d... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 410,
"start_col": 0,
"start_line": 392
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Squaring.bn_sqr a) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.Definitions.bn_v a) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
... | [] | false | false | true | false | false | let bn_sqr_lemma_eval #t #aLen a =
| let pbits = bits t in
let resLen = aLen + aLen in
let res0 = create (aLen + aLen) (uint #t 0) in
let res1 = repeati aLen (bn_sqr_f a) res0 in
let c0, res2 = Hacl.Spec.Bignum.Addition.bn_add res1 res1 in
Hacl.Spec.Bignum.Addition.bn_add_lemma res1 res1;
let tmp = bn_sqr_diag a in
let c1, res3 = Hacl.Spec.Bignum.Addition... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_inductive | val bn_sqr_diag_inductive:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Pure (lbignum t (aLen + aLen))
(requires True)
(ensures fun res ->
(let acc0 = create (aLen + aLen) (uint #t 0) in
res == repeati k (bn_sqr_diag_f a) acc0 /\
(forall (... | val bn_sqr_diag_inductive:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Pure (lbignum t (aLen + aLen))
(requires True)
(ensures fun res ->
(let acc0 = create (aLen + aLen) (uint #t 0) in
res == repeati k (bn_sqr_diag_f a) acc0 /\
(forall (... | let bn_sqr_diag_inductive #t #aLen a k =
let acc0 = create (aLen + aLen) (uint #t 0) in
eq_repeati0 k (bn_sqr_diag_f a) acc0;
repeati_inductive k
(fun i acci ->
acci == repeati i (bn_sqr_diag_f a) acc0 /\
(forall (i0:nat{i0 < i}).
let (hi, lo) = mul_wide a.[i0] a.[i0] in
Seq.index acci (2 *... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 136,
"start_col": 0,
"start_line": 117
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> k: Prims.nat{k <= aLen}
-> Prims.Pure (Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Lib.LoopCombinators.repeati_inductive",
"FStar.Seq.Base.seq",
"Hacl.Spec.Bignum.Definitio... | [] | false | false | false | false | false | let bn_sqr_diag_inductive #t #aLen a k =
| let acc0 = create (aLen + aLen) (uint #t 0) in
eq_repeati0 k (bn_sqr_diag_f a) acc0;
repeati_inductive k
(fun i acci ->
acci == repeati i (bn_sqr_diag_f a) acc0 /\
(forall (i0: nat{i0 < i}).
let hi, lo = mul_wide a.[ i0 ] a.[ i0 ] in
Seq.index acci (2 * i0) == lo /\ Seq.index acci (2 *... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_inductive | val bn_sqr_inductive:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Pure (lbignum t (aLen + aLen))
(requires True)
(ensures fun res ->
(let acc0 = create (aLen + aLen) (uint #t 0) in
res == repeati k (bn_sqr_f a) acc0 /\
(forall (i:nat{k + ... | val bn_sqr_inductive:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k <= aLen} ->
Pure (lbignum t (aLen + aLen))
(requires True)
(ensures fun res ->
(let acc0 = create (aLen + aLen) (uint #t 0) in
res == repeati k (bn_sqr_f a) acc0 /\
(forall (i:nat{k + ... | let bn_sqr_inductive #t #aLen a k =
let acc0 = create (aLen + aLen) (uint #t 0) in
eq_repeati0 k (bn_sqr_f a) acc0;
repeati_inductive #(lbignum t (aLen + aLen)) k
(fun i acci ->
acci == repeati i (bn_sqr_f a) acc0 /\
(forall (i0:nat{i + i < i0 /\ i0 < aLen + aLen}). Seq.index acci i0 == Seq.index acc0 i... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 281,
"start_col": 0,
"start_line": 267
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> k: Prims.nat{k <= aLen}
-> Prims.Pure (Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Lib.LoopCombinators.repeati_inductive",
"Prims.l_and",
"Prims.eq2",
"Lib.LoopCombinator... | [] | false | false | false | false | false | let bn_sqr_inductive #t #aLen a k =
| let acc0 = create (aLen + aLen) (uint #t 0) in
eq_repeati0 k (bn_sqr_f a) acc0;
repeati_inductive #(lbignum t (aLen + aLen))
k
(fun i acci ->
acci == repeati i (bn_sqr_f a) acc0 /\
(forall (i0: nat{i + i < i0 /\ i0 < aLen + aLen}). Seq.index acci i0 == Seq.index acc0 i0))
(fun i acci ->
unfold_r... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f_lemma | val bn_sqr_diag_f_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i < aLen}
-> acc:lbignum t (aLen + aLen) ->
Lemma (let (hi, lo) = mul_wide a.[i] a.[i] in
let res = bn_sqr_diag_f a i acc in
res.[2 * i] == lo /\ res.[2 * i + 1] == hi /\
(forall (i0:na... | val bn_sqr_diag_f_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i < aLen}
-> acc:lbignum t (aLen + aLen) ->
Lemma (let (hi, lo) = mul_wide a.[i] a.[i] in
let res = bn_sqr_diag_f a i acc in
res.[2 * i] == lo /\ res.[2 * i + 1] == hi /\
(forall (i0:na... | let bn_sqr_diag_f_lemma #t #aLen a i acc =
let (hi, lo) = mul_wide a.[i] a.[i] in
let res1 = acc.[2 * i] <- lo in
let res = res1.[2 * i + 1] <- hi in
let aux (i0:nat{i0 < aLen + aLen /\ i0 <> 2 * i /\ i0 <> 2 * i + 1}) :
Lemma (acc.[i0] == res.[i0]) = () in
let aux2 (i0:nat{i0 < aLen /\ i0 <> i}) :
... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 96,
"start_col": 0,
"start_line": 80
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.nat{i < aLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen)
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Base.mul_wide a.[ i ] a.[ i ] in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ hi lo = _ in
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Classical.forall_intro",
... | [] | false | false | true | false | false | let bn_sqr_diag_f_lemma #t #aLen a i acc =
| let hi, lo = mul_wide a.[ i ] a.[ i ] in
let res1 = acc.[ 2 * i ] <- lo in
let res = res1.[ 2 * i + 1 ] <- hi in
let aux (i0: nat{i0 < aLen + aLen /\ i0 <> 2 * i /\ i0 <> 2 * i + 1})
: Lemma (acc.[ i0 ] == res.[ i0 ]) =
()
in
let aux2 (i0: nat{i0 < aLen /\ i0 <> i})
: Lemma (acc.[ 2 * i0 ] == res.[ 2 * i0 ] /... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_f_lemma | val bn_sqr_f_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> j:size_nat{j < aLen}
-> acc:lbignum t (aLen + aLen)
-> i:nat{j + j < i /\ i < aLen + aLen} ->
Lemma (let res = bn_sqr_f a j acc in
eval_ (aLen + aLen) res (j + j + 1) ==
eval_ (aLen + aLen) acc (j + j... | val bn_sqr_f_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> j:size_nat{j < aLen}
-> acc:lbignum t (aLen + aLen)
-> i:nat{j + j < i /\ i < aLen + aLen} ->
Lemma (let res = bn_sqr_f a j acc in
eval_ (aLen + aLen) res (j + j + 1) ==
eval_ (aLen + aLen) acc (j + j... | let bn_sqr_f_lemma #t #aLen a j acc i =
let resLen = aLen + aLen in
let c, acc' = SM.bn_mul1_add_in_place #t #j (sub a 0 j) a.[j] (sub acc j j) in
let acc1 = update_sub acc j j acc' in
assert (index acc1 i == index acc i);
let res = acc1.[j + j] <- c in
assert (index res i == index acc i);
SM.bn_mul1_ls... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 252,
"start_col": 0,
"start_line": 240
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
j: Lib.IntTypes.size_nat{j < aLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + aLen) ->
i: Prims.nat{j + j < i /\ i < aLen + aLen}
-> FStar.Pervasives.Lemma
(ensures
(let res = Hacl.Spec.Bignum.Squaring.bn_sqr_f a j acc in
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Prims.nat",
"Prims.l_and",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bign... | [] | false | false | true | false | false | let bn_sqr_f_lemma #t #aLen a j acc i =
| let resLen = aLen + aLen in
let c, acc' = SM.bn_mul1_add_in_place #t #j (sub a 0 j) a.[ j ] (sub acc j j) in
let acc1 = update_sub acc j j acc' in
assert (index acc1 i == index acc i);
let res = acc1.[ j + j ] <- c in
assert (index res i == index acc i);
SM.bn_mul1_lshift_add_lemma #t #j #resLen (sub a 0 j) a.[ j ] j a... | false |
Benton2004.fst | Benton2004.exec_equiv_reified_trans | val exec_equiv_reified_trans (p p': sttype) (f1 f2 f3: reified_computation)
: Lemma
(requires
(is_per p' /\ interpolable p /\ exec_equiv_reified p p' f1 f2 /\
exec_equiv_reified p p' f2 f3)) (ensures (exec_equiv_reified p p' f1 f3)) | val exec_equiv_reified_trans (p p': sttype) (f1 f2 f3: reified_computation)
: Lemma
(requires
(is_per p' /\ interpolable p /\ exec_equiv_reified p p' f1 f2 /\
exec_equiv_reified p p' f2 f3)) (ensures (exec_equiv_reified p p' f1 f3)) | let exec_equiv_reified_trans
(p p': sttype)
(f1 f2 f3 : reified_computation)
: Lemma
(requires (is_per p' /\ interpolable p /\ exec_equiv_reified p p' f1 f2 /\ exec_equiv_reified p p' f2 f3))
(ensures (exec_equiv_reified p p' f1 f3))
= let prf1
(s1 s3 : heap)
: Lemma
(requires (holds p s1 s3))
(en... | {
"file_name": "examples/rel/Benton2004.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 419,
"start_col": 0,
"start_line": 379
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.IntStoreFixed.fst.checked",
"FStar.DM4F.Heap.IntStoreFixed.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.Aux.fsti.checked"
],
... | [
{
"abbrev": false,
"full_module": "FStar.DM4F.IntStoreFixed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.Heap.IntStoreFixed",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.Aux",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: Benton2004.sttype ->
p': Benton2004.sttype ->
f1: Benton2004.reified_computation ->
f2: Benton2004.reified_computation ->
f3: Benton2004.reified_computation
-> FStar.Pervasives.Lemma
(requires
Benton2004.is_per p' /\ Benton2004.interpolable p /\
Benton2004.exec_equiv_reif... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.sttype",
"Benton2004.reified_computation",
"FStar.Classical.forall_intro_3",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.nat",
"Prims.l_imp",
"Prims.l_and",
"Benton2004.Aux.holds",
"Prims.eq2",
"Prims.bool",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Cl... | [] | false | false | true | false | false | let exec_equiv_reified_trans (p p': sttype) (f1 f2 f3: reified_computation)
: Lemma
(requires
(is_per p' /\ interpolable p /\ exec_equiv_reified p p' f1 f2 /\
exec_equiv_reified p p' f2 f3)) (ensures (exec_equiv_reified p p' f1 f3)) =
| let prf1 (s1 s3: heap)
: Lemma (requires (holds p s1 s3)) (ensures (terminates_on f1 s1 <==> terminates_on f3 s3)) =
interpolable_elim p s1 s3
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (prf1 x));
let prf2 (s1 s3: heap) (fuel: nat)
: Lemma (requires (holds p s1 s3 /\ fst (f1 fuel s1) == tru... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_eq | val bn_sqr_diag_eq:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k < aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (k + 1) (bn_s... | val bn_sqr_diag_eq:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> k:nat{k < aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (k + 1) (bn_s... | let bn_sqr_diag_eq #t #aLen a k =
let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (k + 1) (bn_sqr_diag_f a) acc0 in
let aux (i:nat{i < 2 * k}) : Lemma (Seq.index acc1 i == Seq.index acc2 i) =
... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 184,
"start_col": 0,
"start_line": 168
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> k: Prims.nat{k < aLen}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Sequence.create (aLen + aLen) (Lib.IntTypes.uint 0) in
let acc1 = Lib.LoopCombinators.repeati k (Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f a) acc0 in
let acc2 =
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Prim... | [] | false | false | true | false | false | let bn_sqr_diag_eq #t #aLen a k =
| let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1:lbignum t (aLen + aLen) = repeati k (bn_sqr_diag_f a) acc0 in
let acc2:lbignum t (aLen + aLen) = repeati (k + 1) (bn_sqr_diag_f a) acc0 in
let aux (i: nat{i < 2 * k}) : Lemma (Seq.index acc1 i == Seq.index acc2 i) =
let i2 = i / 2 in
bn_sqr_diag_lemma a k;
b... | false |
Hacl.Impl.SecretBox.fst | Hacl.Impl.SecretBox.secretbox_easy | val secretbox_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> c:lbuffer uint8 (mlen +! 16ul)
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> m:lbuffer uint8 mlen ->
Stack unit
(requires fun h ->
live h c /\ live h m /\ live h k /\ live h n /\
disjoint m c /\ disjoint n m /\ disjoint n c)
(e... | val secretbox_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> c:lbuffer uint8 (mlen +! 16ul)
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> m:lbuffer uint8 mlen ->
Stack unit
(requires fun h ->
live h c /\ live h m /\ live h k /\ live h n /\
disjoint m c /\ disjoint n m /\ disjoint n c)
(e... | let secretbox_easy mlen c k n m =
let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
secretbox_detached mlen cip tag k n m;
let h1 = ST.get () in
FStar.Seq.Properties.lemma_split (as_seq h1 c) 16 | {
"file_name": "code/nacl-box/Hacl.Impl.SecretBox.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 246,
"start_col": 0,
"start_line": 241
} | module Hacl.Impl.SecretBox
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Salsa20
open Hacl.Poly1305_32
module ST = FStar.HyperStack.ST
module Spec = Spec.SecretBox
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 -... | {
"checked_file": "/",
"dependencies": [
"Spec.SecretBox.fst.checked",
"Spec.Salsa20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Poly1305_32.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.SecretBox",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mlen: Lib.IntTypes.size_t{Lib.IntTypes.v mlen + 16 <= Lib.IntTypes.max_size_t} ->
c: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (mlen +! 16ul) ->
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul ->
m: Lib.Buffer.lbuffer Lib.IntTypes.uint8 mlen
-> FStar.Hyp... | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Lib.IntTypes.op_Plus_Bang",
"FStar.UInt32.__uint_to_t",
"FStar.Seq.Properties... | [] | false | true | false | false | false | let secretbox_easy mlen c k n m =
| let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
secretbox_detached mlen cip tag k n m;
let h1 = ST.get () in
FStar.Seq.Properties.lemma_split (as_seq h1 c) 16 | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_eval_square | val bn_eval_square:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:pos{i <= aLen} ->
Lemma (eval_ aLen a i * eval_ aLen a i == eval_ aLen a (i - 1) * eval_ aLen a (i - 1) +
2 * eval_ aLen a (i - 1) * v a.[i - 1] * pow2 (bits t * (i - 1)) + v a.[i - 1] * v a.[i - 1] * pow... | val bn_eval_square:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:pos{i <= aLen} ->
Lemma (eval_ aLen a i * eval_ aLen a i == eval_ aLen a (i - 1) * eval_ aLen a (i - 1) +
2 * eval_ aLen a (i - 1) * v a.[i - 1] * pow2 (bits t * (i - 1)) + v a.[i - 1] * v a.[i - 1] * pow... | let bn_eval_square #t #aLen a i =
let e1 = eval_ aLen a (i - 1) in
let p1 = pow2 (bits t * (i - 1)) in
let p2 = pow2 (bits t * (i + i - 2)) in
calc (==) {
eval_ aLen a i * eval_ aLen a i;
(==) { bn_eval_unfold_i a i }
(e1 + v a.[i - 1] * p1) * (e1 + v a.[i - 1] * p1);
(==) { square_of_sum e1 (v... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 328,
"start_col": 0,
"start_line": 309
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Prims.pos{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.eval_ aLen a i * Hacl.Spec.Bignum.Definitions.eval_ aLen a i ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) *
Hacl.Spec.Bignum.Definitions.eval_ aLen a ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Hacl.Spec.Bi... | [] | false | false | true | false | false | let bn_eval_square #t #aLen a i =
| let e1 = eval_ aLen a (i - 1) in
let p1 = pow2 (bits t * (i - 1)) in
let p2 = pow2 (bits t * (i + i - 2)) in
calc ( == ) {
eval_ aLen a i * eval_ aLen a i;
( == ) { bn_eval_unfold_i a i }
(e1 + v a.[ i - 1 ] * p1) * (e1 + v a.[ i - 1 ] * p1);
( == ) { square_of_sum e1 (v a.[ i - 1 ] * p1) }
e1 * e1 + (2 * e1)... | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_diag_loop_step | val bn_sqr_diag_loop_step:
#t:limb_t
-> #aLen:size_pos{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:pos{i <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (i - ... | val bn_sqr_diag_loop_step:
#t:limb_t
-> #aLen:size_pos{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:pos{i <= aLen} ->
Lemma (let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (i - ... | let bn_sqr_diag_loop_step #t #aLen a i =
let pbits = bits t in
let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1 : lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) acc0 in
let acc2 : lbignum t (aLen + aLen) = repeati (i - 1) (bn_sqr_diag_f a) acc0 in
bn_eval_unfold_i acc1 (i + i);
bn_eval_unfold... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 225,
"start_col": 0,
"start_line": 198
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Prims.pos{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Sequence.create (aLen + aLen) (Lib.IntTypes.uint 0) in
let acc1 = Lib.LoopCombinators.repeati i (Hacl.Spec.Bignum.Squaring.bn_sqr_diag_f a) acc0 in
let acc2 =
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prim... | [] | false | false | true | false | false | let bn_sqr_diag_loop_step #t #aLen a i =
| let pbits = bits t in
let acc0 = create (aLen + aLen) (uint #t 0) in
let acc1:lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) acc0 in
let acc2:lbignum t (aLen + aLen) = repeati (i - 1) (bn_sqr_diag_f a) acc0 in
bn_eval_unfold_i acc1 (i + i);
bn_eval_unfold_i acc1 (i + i - 1);
calc ( == ) {
v acc1.[ i + i - 2 ] ... | false |
Hacl.Impl.SecretBox.fst | Hacl.Impl.SecretBox.secretbox_open_easy | val secretbox_open_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> m:lbuffer uint8 mlen
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> c:lbuffer uint8 (mlen +! 16ul) ->
Stack size_t
(requires fun h ->
live h c /\ live h m /\ live h k /\ live h n /\
disjoint m c /\ disjoint n m /\ disjoint n ... | val secretbox_open_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> m:lbuffer uint8 mlen
-> k:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> c:lbuffer uint8 (mlen +! 16ul) ->
Stack size_t
(requires fun h ->
live h c /\ live h m /\ live h k /\ live h n /\
disjoint m c /\ disjoint n m /\ disjoint n ... | let secretbox_open_easy mlen m k n c =
let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
secretbox_open_detached mlen m k n cip tag | {
"file_name": "code/nacl-box/Hacl.Impl.SecretBox.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 268,
"start_col": 0,
"start_line": 265
} | module Hacl.Impl.SecretBox
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Salsa20
open Hacl.Poly1305_32
module ST = FStar.HyperStack.ST
module Spec = Spec.SecretBox
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 -... | {
"checked_file": "/",
"dependencies": [
"Spec.SecretBox.fst.checked",
"Spec.Salsa20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Poly1305_32.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.SecretBox",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mlen: Lib.IntTypes.size_t{Lib.IntTypes.v mlen + 16 <= Lib.IntTypes.max_size_t} ->
m: Lib.Buffer.lbuffer Lib.IntTypes.uint8 mlen ->
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul ->
c: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (mlen +! 16ul)
-> FStar.Hyp... | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Plus_Bang",
"Hacl.Impl.SecretBox.... | [] | false | true | false | false | false | let secretbox_open_easy mlen m k n c =
| let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
secretbox_open_detached mlen m k n cip tag | false |
Hacl.Impl.SHA2.Core.fst | Hacl.Impl.SHA2.Core.load_last8 | val load_last8: #a:sha2_alg -> #m:m_spec{lanes a m = 8} -> load_last_t a m | val load_last8: #a:sha2_alg -> #m:m_spec{lanes a m = 8} -> load_last_t a m | let load_last8 #a #m totlen_buf len b fin last =
let h0 = ST.get() in
let (b0,(b1,(b2,(b3,(b4,(b5,(b6,b7))))))) = NTup.tup8 b in
let last0 = sub last 0ul (2ul *! HD.block_len a) in
let last1 = sub last (2ul *! HD.block_len a) (2ul *! HD.block_len a) in
let last2 = sub last (4ul *! HD.block_len a) (2ul *! HD.b... | {
"file_name": "code/sha2-mb/Hacl.Impl.SHA2.Core.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 533,
"start_col": 0,
"start_line": 481
} | module Hacl.Impl.SHA2.Core
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.IntVector
open Lib.MultiBuffer
open Spec.Hash.Definitions
//open Hacl.Hash.Definitions // <- defines as_seq which clashes with Lib.Buffer.as_seq
open Hacl.Spec.SHA2.Vec... | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntVector.Transpose.fsti.checked",
"Lib.IntVector.Serialize.fsti.checked",
"Lib.IntVector.fst... | [
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "HD"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.IntVector.Transpose",
"short_module": "VecTranspose"
},
{
"abbrev": t... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Impl.SHA2.Core.load_last_t a m | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Spec.Hash.Definitions.len_len",
"Lib.IntTypes.size_t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.Int... | [] | false | false | false | false | false | let load_last8 #a #m totlen_buf len b fin last =
| let h0 = ST.get () in
let b0, (b1, (b2, (b3, (b4, (b5, (b6, b7)))))) = NTup.tup8 b in
let last0 = sub last 0ul (2ul *! HD.block_len a) in
let last1 = sub last (2ul *! HD.block_len a) (2ul *! HD.block_len a) in
let last2 = sub last (4ul *! HD.block_len a) (2ul *! HD.block_len a) in
let last3 = sub last (6ul *! HD.block_... | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_vec | val eval_vec (v: vec) (s: state) : quad32 | val eval_vec (v: vec) (s: state) : quad32 | let eval_vec (v:vec) (s:state) : quad32 = s.vecs v | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 103,
"start_col": 7,
"start_line": 103
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Vale.PPC64LE.Machine_s.vec -> s: Vale.PPC64LE.Machine_s.state -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Machine_s.vec",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | true | false | let eval_vec (v: vec) (s: state) : quad32 =
| s.vecs v | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_reg | val eval_reg (r: reg) (s: state) : nat64 | val eval_reg (r: reg) (s: state) : nat64 | let eval_reg (r:reg) (s:state) : nat64 = s.regs r | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 102,
"start_col": 7,
"start_line": 102
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.PPC64LE.Machine_s.reg -> s: Vale.PPC64LE.Machine_s.state -> Vale.Def.Types_s.nat64 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.Def.Types_s.nat64"
] | [] | false | false | false | true | false | let eval_reg (r: reg) (s: state) : nat64 =
| s.regs r | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_mem128 | val eval_mem128 (ptr: int) (s: state) : quad32 | val eval_mem128 (ptr: int) (s: state) : quad32 | let eval_mem128 (ptr:int) (s:state) : quad32 = get_heap_val128 ptr (heap_get s.ms_heap) | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 105,
"start_col": 7,
"start_line": 105
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.state -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.MachineHeap_s.get_heap_val128",
"Vale.Arch.Heap.heap_get",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | true | false | let eval_mem128 (ptr: int) (s: state) : quad32 =
| get_heap_val128 ptr (heap_get s.ms_heap) | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_mem | val eval_mem (ptr: int) (s: state) : nat64 | val eval_mem (ptr: int) (s: state) : nat64 | let eval_mem (ptr:int) (s:state) : nat64 = get_heap_val64 ptr (heap_get s.ms_heap) | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 104,
"start_col": 7,
"start_line": 104
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.state -> Vale.Def.Types_s.nat64 | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.MachineHeap_s.get_heap_val64",
"Vale.Arch.Heap.heap_get",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.Def.Types_s.nat64"
] | [] | false | false | false | true | false | let eval_mem (ptr: int) (s: state) : nat64 =
| get_heap_val64 ptr (heap_get s.ms_heap) | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_stack | val eval_stack (ptr: int) (s: machine_stack) : nat64 | val eval_stack (ptr: int) (s: machine_stack) : nat64 | let eval_stack (ptr:int) (s:machine_stack) : nat64 =
let Machine_stack _ mem = s in
get_heap_val64 ptr mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 109,
"start_col": 7,
"start_line": 107
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.machine_stack -> Vale.Def.Types_s.nat64 | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.Arch.MachineHeap_s.get_heap_val64",
"Vale.Def.Types_s.nat64"
] | [] | false | false | false | true | false | let eval_stack (ptr: int) (s: machine_stack) : nat64 =
| let Machine_stack _ mem = s in
get_heap_val64 ptr mem | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.eval_stack128 | val eval_stack128 (ptr: int) (s: machine_stack) : quad32 | val eval_stack128 (ptr: int) (s: machine_stack) : quad32 | let eval_stack128 (ptr:int) (s:machine_stack) : quad32 =
let Machine_stack _ mem = s in
get_heap_val128 ptr mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 112,
"start_col": 7,
"start_line": 110
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.machine_stack -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.Arch.MachineHeap_s.get_heap_val128",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | true | false | let eval_stack128 (ptr: int) (s: machine_stack) : quad32 =
| let Machine_stack _ mem = s in
get_heap_val128 ptr mem | false |
Hacl.Spec.Bignum.Squaring.fst | Hacl.Spec.Bignum.Squaring.bn_sqr_loop_lemma | val bn_sqr_loop_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let resLen = aLen + aLen in
let bn_zero = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati i (bn_sqr_f a) bn_zero in
let tmp : lbignum t (aL... | val bn_sqr_loop_lemma:
#t:limb_t
-> #aLen:size_nat{aLen + aLen <= max_size_t}
-> a:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let resLen = aLen + aLen in
let bn_zero = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati i (bn_sqr_f a) bn_zero in
let tmp : lbignum t (aL... | let rec bn_sqr_loop_lemma #t #aLen a i =
let pbits = bits t in
let resLen = aLen + aLen in
let bn_zero = create (aLen + aLen) (uint #t 0) in
let acc : lbignum t (aLen + aLen) = repeati i (bn_sqr_f a) bn_zero in
let tmp : lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) bn_zero in
if i = 0 then begin
... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Squaring.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 386,
"start_col": 0,
"start_line": 343
} | module Hacl.Spec.Bignum.Squaring
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
module SM = Hacl.Spec.Bignum.Multiplication
module SA = Hacl.Spec.Bignum.Addition
#reset-options "--z3rlimit 50 --fuel 0 --ifu... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Multiplication.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Sp... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "SA"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Multiplication",
"short_module": "SM"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev":... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let resLen = aLen + aLen in
let bn_zero = Lib.Sequence.create (aLen + aLen) (Lib.IntTypes.uint 0) in
let acc = Lib.LoopCombinators.repeati i (Hacl.Spec.Bignum.Squaring.bn_sqr_f a) bn... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.unit",... | [
"recursion"
] | false | false | true | false | false | let rec bn_sqr_loop_lemma #t #aLen a i =
| let pbits = bits t in
let resLen = aLen + aLen in
let bn_zero = create (aLen + aLen) (uint #t 0) in
let acc:lbignum t (aLen + aLen) = repeati i (bn_sqr_f a) bn_zero in
let tmp:lbignum t (aLen + aLen) = repeati i (bn_sqr_diag_f a) bn_zero in
if i = 0
then
(bn_eval0 acc;
bn_eval0 tmp;
bn_eval0 a)
else
let p1 ... | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_stack64' | val update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack | val update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack | let update_stack64' (ptr:int) (v:nat64) (s:machine_stack) : machine_stack =
let Machine_stack init_r1 mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_r1 mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 218,
"start_col": 0,
"start_line": 215
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> v: Vale.Def.Types_s.nat64 -> s: Vale.PPC64LE.Machine_s.machine_stack
-> Vale.PPC64LE.Machine_s.machine_stack | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.PPC64LE.Machine_s.Machine_stack",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.Mach... | [] | false | false | false | true | false | let update_stack64' (ptr: int) (v: nat64) (s: machine_stack) : machine_stack =
| let Machine_stack init_r1 mem = s in
let mem = update_heap64 ptr v mem in
Machine_stack init_r1 mem | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_stack128' | val update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack | val update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack | let update_stack128' (ptr:int) (v:quad32) (s:machine_stack) : machine_stack =
let Machine_stack init_r1 mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_r1 mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 224,
"start_col": 0,
"start_line": 221
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> v: Vale.Def.Types_s.quad32 -> s: Vale.PPC64LE.Machine_s.machine_stack
-> Vale.PPC64LE.Machine_s.machine_stack | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.PPC64LE.Machine_s.Machine_stack",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.Mac... | [] | false | false | false | true | false | let update_stack128' (ptr: int) (v: quad32) (s: machine_stack) : machine_stack =
| let Machine_stack init_r1 mem = s in
let mem = update_heap128 ptr v mem in
Machine_stack init_r1 mem | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_stack_and_taint | val update_stack_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : state | val update_stack_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : state | let update_stack_and_taint (ptr:int) (v:nat64) (s:state) (t:taint) : state =
let Machine_stack init_r1 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;
} | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 231,
"start_col": 0,
"start_line": 226
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
ptr: Prims.int ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.PPC64LE.Machine_s.state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.PPC64LE.Machine_s.state | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstat... | [] | false | false | false | true | false | let update_stack_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : state =
| let Machine_stack init_r1 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 |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_stack128_and_taint | val update_stack128_and_taint (ptr: int) (v: quad32) (s: state) (t: taint) : state | val update_stack128_and_taint (ptr: int) (v: quad32) (s: state) (t: taint) : state | let update_stack128_and_taint (ptr:int) (v:quad32) (s:state) (t:taint) : state =
let Machine_stack init_r1 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
} | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 238,
"start_col": 0,
"start_line": 233
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
ptr: Prims.int ->
v: Vale.Def.Types_s.quad32 ->
s: Vale.PPC64LE.Machine_s.state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.PPC64LE.Machine_s.state | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.HeapTypes_s.taint",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mksta... | [] | false | false | false | true | false | let update_stack128_and_taint (ptr: int) (v: quad32) (s: state) (t: taint) : state =
| let Machine_stack init_r1 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 |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.valid_src_stack64 | val valid_src_stack64 (ptr: int) (st: machine_stack) : bool | val valid_src_stack64 (ptr: int) (st: machine_stack) : bool | let valid_src_stack64 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_r1 mem = st in
valid_addr64 ptr mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 243,
"start_col": 0,
"start_line": 241
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> st: Vale.PPC64LE.Machine_s.machine_stack -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Prims.bool"
] | [] | false | false | false | true | false | let valid_src_stack64 (ptr: int) (st: machine_stack) : bool =
| let Machine_stack init_r1 mem = st in
valid_addr64 ptr mem | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.valid_src_stack128 | val valid_src_stack128 (ptr: int) (st: machine_stack) : bool | val valid_src_stack128 (ptr: int) (st: machine_stack) : bool | let valid_src_stack128 (ptr:int) (st:machine_stack) : bool =
let Machine_stack init_r1 mem = st in
valid_addr128 ptr mem | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 248,
"start_col": 0,
"start_line": 246
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> st: Vale.PPC64LE.Machine_s.machine_stack -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Vale.PPC64LE.Machine_s.nat8",
"Vale.Arch.MachineHeap_s.valid_addr128",
"Prims.bool"
] | [] | false | false | false | true | false | let valid_src_stack128 (ptr: int) (st: machine_stack) : bool =
| let Machine_stack init_r1 mem = st in
valid_addr128 ptr mem | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.valid_src_stack64_and_taint | val valid_src_stack64_and_taint (ptr: int) (s: state) (t: taint) : bool | val valid_src_stack64_and_taint (ptr: int) (s: state) (t: taint) : bool | let valid_src_stack64_and_taint (ptr:int) (s:state) (t:taint) : bool =
valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 252,
"start_col": 0,
"start_line": 251
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.state -> t: Vale.Arch.HeapTypes_s.taint -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.HeapTypes_s.taint",
"Prims.op_AmpAmp",
"Vale.PPC64LE.Semantics_s.valid_src_stack64",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Semantics_s.match_n",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint",
"P... | [] | false | false | false | true | false | let valid_src_stack64_and_taint (ptr: int) (s: state) (t: taint) : bool =
| valid_src_stack64 ptr s.ms_stack && match_n ptr 8 s.ms_stackTaint t | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.match_n | 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) | 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)
=
if n = 0 then true
else if memTaint.[addr] <> t then false
else match_n (addr + 1) (n - 1) ... | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 130,
"start_col": 0,
"start_line": 122
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
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)... | Prims.Tot | [
"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.PPC64LE.Semantics_s.op_String_Access",
"Vale.PPC64LE.Semantics_s.match_n",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Prims.l_iff",
... | [
"recursion"
] | false | false | false | false | 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 | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_n | val 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) | val 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) | 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 ... | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 141,
"start_col": 0,
"start_line": 133
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
addr: Prims.int ->
n: Prims.nat ->
memTaint: Vale.Arch.HeapTypes_s.memTaint_t ->
t: Vale.Arch.HeapTypes_s.taint
-> Prims.Tot
(m:
Vale.Arch.HeapTypes_s.memTaint_t
{ forall (i: Prims.int). {:pattern FStar.Map.sel m i}
(i >= addr /\ i < addr + n ==> m.[ i ] == t) /\
... | Prims.Tot | [
"total",
""
] | [] | [
"Prims.int",
"Prims.nat",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.Arch.HeapTypes_s.taint",
"Prims.op_Equality",
"Prims.bool",
"Vale.PPC64LE.Semantics_s.update_n",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Vale.PPC64LE.Semantics_s.op_String_Assignment",
"Prims.l_Forall",
"Prims.l_and",
... | [
"recursion"
] | false | false | false | false | false | 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 | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.valid_src_stack128_and_taint | val valid_src_stack128_and_taint (ptr: int) (s: state) (t: taint) : bool | val valid_src_stack128_and_taint (ptr: int) (s: state) (t: taint) : bool | let valid_src_stack128_and_taint (ptr:int) (s:state) (t:taint) : bool =
valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 256,
"start_col": 0,
"start_line": 255
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> s: Vale.PPC64LE.Machine_s.state -> t: Vale.Arch.HeapTypes_s.taint -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.HeapTypes_s.taint",
"Prims.op_AmpAmp",
"Vale.PPC64LE.Semantics_s.valid_src_stack128",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Semantics_s.match_n",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint",
"... | [] | false | false | false | true | false | let valid_src_stack128_and_taint (ptr: int) (s: state) (t: taint) : bool =
| valid_src_stack128 ptr s.ms_stack && match_n ptr 16 s.ms_stackTaint t | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.valid_src_stack | val valid_src_stack (r: reg) (s: state) : bool | val valid_src_stack (r: reg) (s: state) : bool | let valid_src_stack (r:reg) (s:state) : bool =
valid_src_stack64 (eval_reg r s) s.ms_stack | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 259,
"start_col": 0,
"start_line": 258
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Vale.PPC64LE.Machine_s.reg -> s: Vale.PPC64LE.Machine_s.state -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Semantics_s.valid_src_stack64",
"Vale.PPC64LE.Semantics_s.eval_reg",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Prims.bool"
] | [] | false | false | false | true | false | let valid_src_stack (r: reg) (s: state) : bool =
| valid_src_stack64 (eval_reg r s) s.ms_stack | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_mem | val update_mem (ptr: int) (v: nat64) (s: state) : state | val update_mem (ptr: int) (v: nat64) (s: state) : state | let update_mem (ptr:int) (v:nat64) (s:state) : 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))
(heap_taint s.ms_heap)
}
else s | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 169,
"start_col": 0,
"start_line": 162
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ptr: Prims.int -> v: Vale.Def.Types_s.nat64 -> s: Vale.PPC64LE.Machine_s.state
-> Vale.PPC64LE.Machine_s.state | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Vale.Arch.Heap.heap_get",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Machi... | [] | false | false | false | true | false | let update_mem (ptr: int) (v: nat64) (s: state) : 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)) (heap_taint s.ms_heap)
}
else s | false |
Vale.PPC64LE.Semantics_s.fst | Vale.PPC64LE.Semantics_s.update_mem_and_taint | val update_mem_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : state | val update_mem_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : state | let update_mem_and_taint (ptr:int) (v:nat64) (s:state) (t:taint) : 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 | {
"file_name": "vale/specs/hardware/Vale.PPC64LE.Semantics_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 160,
"start_col": 0,
"start_line": 153
} | module Vale.PPC64LE.Semantics_s
open FStar.Mul
open FStar.Seq.Base
open Vale.PPC64LE.Machine_s
open Vale.Def.Words_s
open Vale.Def.Words.Two_s
open Vale.Def.Words.Four_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
include Vale.Arch.MachineHeap_s
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.Arch.Types
o... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
ptr: Prims.int ->
v: Vale.Def.Types_s.nat64 ->
s: Vale.PPC64LE.Machine_s.state ->
t: Vale.Arch.HeapTypes_s.taint
-> Vale.PPC64LE.Machine_s.state | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Vale.Def.Types_s.nat64",
"Vale.PPC64LE.Machine_s.state",
"Vale.Arch.HeapTypes_s.taint",
"Vale.Arch.MachineHeap_s.valid_addr64",
"Vale.Arch.Heap.heap_get",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate_... | [] | false | false | false | true | false | let update_mem_and_taint (ptr: int) (v: nat64) (s: state) (t: taint) : 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 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.