Fix builtins

Cargo.toml

@@ -21,6 +21,7 @@ num-bigint = "0.4.6"
 strum = { version = "0.27.1", features = ["strum_macros"] }
 strum_macros = "0.27.1"
 tempfile = "3.20.0"
+blst = "0.3.11"
 
 [profile.release]
 opt-level = 3

linker/link.ld

@@ -57,7 +57,7 @@ SECTIONS
   {
     __stack_bottom = .;
     *(.stack*)
-    . = . + 0x100000;  /* Allocate 1MB of stack space */
+    . = . + 0x400000;  /* Allocate 4MB of stack space */
     __stack_top = .;
   } > STACK
 }

runtime/.zig-global/b/09924bbab0c6c8f4a9c1ddd7922eccc0/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/112b02c9f034e4a7b79de578ce492ce3/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/1c824921f9212a874dbd27ba2ea9078c/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/2787dea0087f88672aa6dc6b4869e3f1/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/408836e1062040ede1b34de526c3295b/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/4344b60649f94a3839970d2e5cb7c614/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;

runtime/.zig-global/b/4d267d370019a3c56b20c9f87cc47634/builtin.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+/// Zig version. When writing code that supports multiple versions of Zig, prefer
+/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
+pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable;
+pub const zig_version_string = "0.15.0-dev.833+5f7780c53";
+pub const zig_backend = std.builtin.CompilerBackend.stage2_llvm;
+
+pub const output_mode: std.builtin.OutputMode = .Obj;
+pub const link_mode: std.builtin.LinkMode = .static;
+pub const unwind_tables: std.builtin.UnwindTables = .none;
+pub const is_test = false;
+pub const single_threaded = false;
+pub const abi: std.Target.Abi = .none;
+pub const cpu: std.Target.Cpu = .{
+    .arch = .riscv32,
+    .model = &std.Target.riscv.cpu.baseline_rv32,
+    .features = std.Target.riscv.featureSet(&.{
+        .@"32bit",
+        .i,
+        .m,
+        .zaamo,
+        .zalrsc,
+        .zmmul,
+    }),
+};
+pub const os: std.Target.Os = .{
+    .tag = .freestanding,
+    .version_range = .{ .none = {} },
+};
+pub const target: std.Target = .{
+    .cpu = cpu,
+    .os = os,
+    .abi = abi,
+    .ofmt = object_format,
+    .dynamic_linker = .none,
+};
+pub const object_format: std.Target.ObjectFormat = .elf;
+pub const mode: std.builtin.OptimizeMode = .ReleaseFast;
+pub const link_libc = false;
+pub const link_libcpp = false;
+pub const have_error_return_tracing = false;
+pub const valgrind_support = false;
+pub const sanitize_thread = false;
+pub const fuzz = false;
+pub const position_independent_code = false;
+pub const position_independent_executable = false;
+pub const strip_debug_info = false;
+pub const code_model: std.builtin.CodeModel = .default;
+pub const omit_frame_pointer = false;