diff --git a/lib/c.zig b/lib/c.zig
index c08454a22c8ecc607dcdc51d91da11c2d52f0ddf..4a6ca187823c4583739b7a88a9d733be87474751 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -58,7 +58,7 @@ comptime {
 
 // Avoid dragging in the runtime safety mechanisms into this .o file,
 // unless we're trying to test this file.
-pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     @setCold(true);
     _ = error_return_trace;
     if (builtin.is_test) {
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index 0147bd423b01c21869fbe4bb10c108c9e77f523b..a34b88429f534f1608d1559822dca92da20f281a 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -60,7 +60,7 @@ pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
 // Avoid dragging in the runtime safety mechanisms into this .o file,
 // unless we're trying to test compiler-rt.
-pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = error_return_trace;
     if (builtin.is_test) {
         @setCold(true);
diff --git a/lib/ssp.zig b/lib/ssp.zig
index b205a09e0a5d545c94fe97de9bb84ad2444ee014..f11698750d3a098646338d0e0804dc319abbe4e3 100644
--- a/lib/ssp.zig
+++ b/lib/ssp.zig
@@ -20,7 +20,7 @@ extern fn memcpy(noalias dest: ?[*]u8, noalias src: ?[*]const u8, n: usize) call
 extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.C) ?[*]u8;
 
 // Avoid dragging in the runtime safety mechanisms into this .o file.
-pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = msg;
     _ = error_return_trace;
     @setCold(true);
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index d65e12988db0de327af88af72db1c420b591e26a..aff47ac6ba0d35d4b30ebd382159444e05ff0a08 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -748,7 +748,7 @@ const testFnProto = switch (builtin.zig_backend) {
 
 /// This function type is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const PanicFn = fn ([]const u8, ?*StackTrace) noreturn;
+pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn;
 
 /// This function is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
@@ -761,7 +761,7 @@ else
 
 /// This function is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn {
+pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr: ?usize) noreturn {
     @setCold(true);
 
     // Until self-hosted catches up with stage1 language features, we have a simpler
@@ -839,7 +839,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn
             std.os.abort();
         },
         else => {
-            const first_trace_addr = @returnAddress();
+            const first_trace_addr = ret_addr orelse @returnAddress();
             std.debug.panicImpl(error_return_trace, first_trace_addr, msg);
         },
     }
@@ -853,17 +853,17 @@ pub fn checkNonScalarSentinel(expected: anytype, actual: @TypeOf(expected)) void
 
 pub fn panicSentinelMismatch(expected: anytype, actual: @TypeOf(expected)) noreturn {
     @setCold(true);
-    std.debug.panic("sentinel mismatch: expected {any}, found {any}", .{ expected, actual });
+    std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ expected, actual });
 }
 
 pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn {
     @setCold(true);
-    std.debug.panicExtra(st, "attempt to unwrap error: {s}", .{@errorName(err)});
+    std.debug.panicExtra(st, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)});
 }
 
 pub fn panicOutOfBounds(index: usize, len: usize) noreturn {
     @setCold(true);
-    std.debug.panic("index out of bounds: index {d}, len {d}", .{ index, len });
+    std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len });
 }
 
 pub noinline fn returnError(st: *StackTrace) void {
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index a7f0b202cbd3d869a953496f04e238a16022a985..cfe646647b954d4e1a5b395553e4d74ea8c94fee 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -284,13 +284,14 @@ pub fn assert(ok: bool) void {
 pub fn panic(comptime format: []const u8, args: anytype) noreturn {
     @setCold(true);
 
-    panicExtra(null, format, args);
+    panicExtra(null, null, format, args);
 }
 
 /// `panicExtra` is useful when you want to print out an `@errorReturnTrace`
 /// and also print out some values.
 pub fn panicExtra(
     trace: ?*std.builtin.StackTrace,
+    ret_addr: ?usize,
     comptime format: []const u8,
     args: anytype,
 ) noreturn {
@@ -308,7 +309,7 @@ pub fn panicExtra(
             break :blk &buf;
         },
     };
-    std.builtin.panic(msg, trace);
+    std.builtin.panic(msg, trace, ret_addr);
 }
 
 /// Non-zero whenever the program triggered a panic.
diff --git a/src/Sema.zig b/src/Sema.zig
index 1bd31ac8f97e1e7dc156d5f4f3cdea18ebefcd67..82593f39357a1bc89cb8fdfa8905f124782dd057 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1955,7 +1955,7 @@ fn failWithOwnedErrorMsg(sema: *Sema, err_msg: *Module.ErrorMsg) CompileError {
             err_msg.src_loc.file_scope.sub_file_path,
             err_msg.src_loc.lazy,
         });
-        crash_report.compilerPanic("unexpected compile error occurred", null);
+        crash_report.compilerPanic("unexpected compile error occurred", null, null);
     }
 
     const mod = sema.mod;
@@ -10468,7 +10468,7 @@ fn maybeErrorUnwrap(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, op
 
                 const panic_fn = try sema.getBuiltin(block, src, "panic");
                 const err_return_trace = try sema.getErrorReturnTrace(block, src);
-                const args: [2]Air.Inst.Ref = .{ msg_inst, err_return_trace };
+                const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value };
                 _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args, null);
                 return true;
             },
@@ -21139,7 +21139,7 @@ fn panicWithMsg(
         try Type.optional(arena, ptr_stack_trace_ty),
         Value.@"null",
     );
-    const args: [2]Air.Inst.Ref = .{ msg_inst, null_stack_trace };
+    const args: [3]Air.Inst.Ref = .{ msg_inst, null_stack_trace, .null_value };
     _ = try sema.analyzeCall(block, panic_fn, src, src, .auto, false, &args, null);
     return always_noreturn;
 }
diff --git a/src/crash_report.zig b/src/crash_report.zig
index d38f436aa00abd47ac7273ef0b27cf69696e33f4..04fbabca09fc823eb499a004d1913945e9a78d2a 100644
--- a/src/crash_report.zig
+++ b/src/crash_report.zig
@@ -155,10 +155,10 @@ fn writeFullyQualifiedDeclWithFile(mod: *Module, decl: *Decl, stream: anytype) !
     try decl.renderFullyQualifiedDebugName(mod, stream);
 }
 
-pub fn compilerPanic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn compilerPanic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, maybe_ret_addr: ?usize) noreturn {
     PanicSwitch.preDispatch();
     @setCold(true);
-    const ret_addr = @returnAddress();
+    const ret_addr = maybe_ret_addr orelse @returnAddress();
     const stack_ctx: StackContext = .{ .current = .{ .ret_addr = ret_addr } };
     PanicSwitch.dispatch(error_return_trace, stack_ctx, msg);
 }
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index 55aa73a3b73513580d27fb23e86725051d1b3b8b..2341ad4483d58d79fc417bb7857a4f8320d52c07 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -1086,11 +1086,23 @@ static void gen_panic(CodeGen *g, LLVMValueRef msg_arg, LLVMValueRef stack_trace
     if (stack_trace_arg == nullptr) {
         stack_trace_arg = LLVMConstNull(get_llvm_type(g, ptr_to_stack_trace_type(g)));
     }
+    LLVMValueRef null_ret_alloc;
+    {
+        ZigValue null_val = {};
+        null_val.special = ConstValSpecialStatic;
+        null_val.data.x_optional = nullptr;
+        null_val.type = get_optional_type2(g, g->builtin_types.entry_usize);
+        LLVMValueRef null_ret_val = gen_const_val(g, &null_val, "");
+        null_ret_alloc = build_alloca(g, null_val.type, "ret_addr", 0);
+        LLVMBuildStore(g->builder, null_ret_val, null_ret_alloc);
+    }
+
     LLVMValueRef args[] = {
         msg_arg,
         stack_trace_arg,
+        null_ret_alloc,
     };
-    ZigLLVMBuildCall(g->builder, LLVMGlobalGetValueType(fn_val), fn_val, args, 2, llvm_cc, ZigLLVM_CallAttrAuto, "");
+    ZigLLVMBuildCall(g->builder, LLVMGlobalGetValueType(fn_val), fn_val, args, 3, llvm_cc, ZigLLVM_CallAttrAuto, "");
     if (!stack_trace_is_llvm_alloca) {
         // The stack trace argument is not in the stack of the caller, so
         // we'd like to set tail call here, but because slices (the type of msg_arg) are
diff --git a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
index 45de2fc6cbc56d23259efb73993207e1c44841a5..37af5e5fce81fbe1e5567cb07fa20eead57a5ab0 100644
--- a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
+++ b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
@@ -1,4 +1,4 @@
-pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
+pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace, _: ?usize) noreturn {
     _ = msg; _ = error_return_trace;
     while (true) {}
 }
@@ -8,5 +8,5 @@ const builtin = @import("std").builtin;
 // backend=stage1
 // target=native
 //
-// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,anytype) anytype'
+// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace, ?usize) noreturn', found 'fn([]const u8,anytype,anytype) anytype'
 // note: only one of the functions is generic
diff --git a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
index 049becaeb14b209250c5c7ea712016d36757ae1f..3848a5bf0c0d262f26c3ee0723e62ec094724fbb 100644
--- a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
+++ b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
@@ -7,4 +7,4 @@ pub fn panic() void {}
 // backend=stage1
 // target=native
 //
-// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'
+// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace, ?usize) noreturn', found 'fn() void'
diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig
index e9530e83fe51a2c3c7a03a1d24e9367bdc5adf25..aed805cf66bfcbedc6dd12391f51f6797b7c4506 100644
--- a/test/cases/safety/@alignCast misaligned.zig	
+++ b/test/cases/safety/@alignCast misaligned.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@asyncCall with too small a frame.zig b/test/cases/safety/@asyncCall with too small a frame.zig
index e245e9bb47436c5e787437d3e8c70c070a886483..1a315930584ce83570bde72d2039b168935c20e4 100644
--- a/test/cases/safety/@asyncCall with too small a frame.zig	
+++ b/test/cases/safety/@asyncCall with too small a frame.zig	
@@ -1,7 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/@errSetCast error not present in destination.zig b/test/cases/safety/@errSetCast error not present in destination.zig
index bf4dee8421c8b91ea01f4c9d3cecfda4ea2d3fe0..2fd0a912e66042e2e54daec995eb07b6c979bc77 100644
--- a/test/cases/safety/@errSetCast error not present in destination.zig	
+++ b/test/cases/safety/@errSetCast error not present in destination.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@floatToInt cannot fit - negative out of range.zig b/test/cases/safety/@floatToInt cannot fit - negative out of range.zig
index 937e77a17334a8a402afa3fcc4d3f10f8ddc3fad..fa7e628f4a0296761ff0bfc4e77f69b51afa6037 100644
--- a/test/cases/safety/@floatToInt cannot fit - negative out of range.zig	
+++ b/test/cases/safety/@floatToInt cannot fit - negative out of range.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@floatToInt cannot fit - negative to unsigned.zig b/test/cases/safety/@floatToInt cannot fit - negative to unsigned.zig
index 65da9b2da5fb50d0d1d34dd00bf32f805502d02e..5bab7710b13a6e6bfc4b77de996c1481e9e0d770 100644
--- a/test/cases/safety/@floatToInt cannot fit - negative to unsigned.zig	
+++ b/test/cases/safety/@floatToInt cannot fit - negative to unsigned.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@floatToInt cannot fit - positive out of range.zig b/test/cases/safety/@floatToInt cannot fit - positive out of range.zig
index e7abf0cf6391d2f226047aa004f97f460a48a216..fe931e8751532047930e0ef4782ae8f990641652 100644
--- a/test/cases/safety/@floatToInt cannot fit - positive out of range.zig	
+++ b/test/cases/safety/@floatToInt cannot fit - positive out of range.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig
index 0f38d59e50ed61f5586c1c7dba7e1b0c6ff7fafb..f3f969548bdfb3a2a097bd4bc20ce4695bdfda79 100644
--- a/test/cases/safety/@intCast to u0.zig	
+++ b/test/cases/safety/@intCast to u0.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intToEnum - no matching tag value.zig b/test/cases/safety/@intToEnum - no matching tag value.zig
index 0e5f401f6da18c2ce92f9837697d6e0bb1c8f8f1..c4967b413b8023631a5f93a2b4114782efb3fb22 100644
--- a/test/cases/safety/@intToEnum - no matching tag value.zig	
+++ b/test/cases/safety/@intToEnum - no matching tag value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intToPtr address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@intToPtr address zero to non-optional byte-aligned pointer.zig
index a3b7f374cebc423fdb7d4d1129fa4567f66d3b67..413959706faa1d6d67d58a419ab072308acae8da 100644
--- a/test/cases/safety/@intToPtr address zero to non-optional byte-aligned pointer.zig	
+++ b/test/cases/safety/@intToPtr address zero to non-optional byte-aligned pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intToPtr address zero to non-optional pointer.zig b/test/cases/safety/@intToPtr address zero to non-optional pointer.zig
index 8724e98131ff6272a9f0360d9ae28798ab9244af..457b2d12c07e1fe4cec3ba116372bea1136b6d17 100644
--- a/test/cases/safety/@intToPtr address zero to non-optional pointer.zig	
+++ b/test/cases/safety/@intToPtr address zero to non-optional pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig
index 4081d171c48e523c374666ec034a3090e2e10a60..344b75effe7568c730238037e8b24179157daa01 100644
--- a/test/cases/safety/@tagName on corrupted enum value.zig	
+++ b/test/cases/safety/@tagName on corrupted enum value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig
index eb36fab2620c88f6de98f814a186df81290aa7dd..f7ffb07871ad6015dece80026411d2e54b9b6c66 100644
--- a/test/cases/safety/@tagName on corrupted union value.zig	
+++ b/test/cases/safety/@tagName on corrupted union value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/array slice sentinel mismatch non-scalar.zig b/test/cases/safety/array slice sentinel mismatch non-scalar.zig
index e773b165e8908cecf68186f8dfaeb8c9eb8ca700..6ea136bc0140c0e926f26feca0b61806064b385b 100644
--- a/test/cases/safety/array slice sentinel mismatch non-scalar.zig	
+++ b/test/cases/safety/array slice sentinel mismatch non-scalar.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected tmp.main.S{ .a = 1 }, found tmp.main.S{ .a = 2 }")) {
         std.process.exit(0);
diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig
index 38d020d84a42634094d902cb4577cee66121aad1..da20d988691f23dce04855201d41f734dce2e243 100644
--- a/test/cases/safety/array slice sentinel mismatch vector.zig	
+++ b/test/cases/safety/array slice sentinel mismatch vector.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
         std.process.exit(0);
diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig
index 8f54b4cc538d599f6ca49ab0e4ba5f9f2a64db4e..fc196186732d58c82f6056c356fb81c5205df768 100644
--- a/test/cases/safety/array slice sentinel mismatch.zig	
+++ b/test/cases/safety/array slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/awaiting twice.zig b/test/cases/safety/awaiting twice.zig
index 867263de6e5623a07cf712df55193a9084e3406c..6767ad4e767dba58c7b3c4292f2d936c5826c833 100644
--- a/test/cases/safety/awaiting twice.zig	
+++ b/test/cases/safety/awaiting twice.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig
index bdde8d9f3a7b44e6e920680cce8a4cfe75b2225f..0badf380fb94072fa8f26f199e59948b1f503818 100644
--- a/test/cases/safety/bad union field access.zig	
+++ b/test/cases/safety/bad union field access.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "access of inactive union field")) {
         std.process.exit(0);
diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig
index 29f3a6c66334efc149bcaecfbd6b7e263ee87e92..832bc5f19ad2bde55213cd871b200d3a92b53619 100644
--- a/test/cases/safety/calling panic.zig	
+++ b/test/cases/safety/calling panic.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "oh no")) {
         std.process.exit(0);
diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig
index 6fddb63bee0c83f37dd4b002399ad39367938c50..93d18178a84f165e1d1631d1a023581275e12dee 100644
--- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
+++ b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/cast integer to global error and no code matches.zig b/test/cases/safety/cast integer to global error and no code matches.zig
index d423704039ee02c1bcae18831b7f83e8aa02ce95..466bf8d2ca66d945cff62dfc307db09d6eeb69c7 100644
--- a/test/cases/safety/cast integer to global error and no code matches.zig	
+++ b/test/cases/safety/cast integer to global error and no code matches.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig
index d989a33541c18fa4eff86c4ee81762ee2205d8c9..69201fde307c7e5c2c13f34780a171dda1b34990 100644
--- a/test/cases/safety/empty slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/empty slice with sentinel out of bounds.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
         std.process.exit(0);
diff --git a/test/cases/safety/error return trace across suspend points.zig b/test/cases/safety/error return trace across suspend points.zig
index b8cb90505ab7b8efa23257a55ff49d3c31e89ebd..28c53cb6d1444bfe6c4f8924a40a73dc88e13ad5 100644
--- a/test/cases/safety/error return trace across suspend points.zig	
+++ b/test/cases/safety/error return trace across suspend points.zig	
@@ -1,7 +1,7 @@
 const std = @import("std");
 
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig
index 9b792b33cf58460cefb2ad6c4de2065303cf000e..3c515cbdf118c3abaa2aea5b698c420796dc3b0b 100644
--- a/test/cases/safety/exact division failure - vectors.zig	
+++ b/test/cases/safety/exact division failure - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig
index ea4d39ed22801529c90fc7e6d4073ac9af97c69b..cdf1b1fb8d31809e308b1235572e473be5cb4c1f 100644
--- a/test/cases/safety/exact division failure.zig	
+++ b/test/cases/safety/exact division failure.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/intToPtr with misaligned address.zig b/test/cases/safety/intToPtr with misaligned address.zig
index 6cb085a64bc96e81790eed8ad77f5e2a3e9a3ec8..e53c7e90871df9ff2587e183fab6636784fd2ef8 100644
--- a/test/cases/safety/intToPtr with misaligned address.zig	
+++ b/test/cases/safety/intToPtr with misaligned address.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig
index aa2ab60dd493cf9760d8456e379c71ac0bc09372..4f7c5b2cb3f5570a621497b822b4b683ed8dd358 100644
--- a/test/cases/safety/integer addition overflow.zig	
+++ b/test/cases/safety/integer addition overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig
index 0789f7f08814d650bf64c22b9d9dca21f3010dcb..ed7ac7777b4b19c3c518b370e45737b42db9278c 100644
--- a/test/cases/safety/integer division by zero - vectors.zig	
+++ b/test/cases/safety/integer division by zero - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig
index 46f57c11178f6948780f90f93903f578c8dc28fe..0d1b79d26d8f2fa8d8f8553b8d2e1319f16df9df 100644
--- a/test/cases/safety/integer division by zero.zig	
+++ b/test/cases/safety/integer division by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig
index af7e6383817c6d1015f345a7d9497b109515cae8..641801277dbd38eef497144adb4398f94bdae539 100644
--- a/test/cases/safety/integer multiplication overflow.zig	
+++ b/test/cases/safety/integer multiplication overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig
index e48ffff761ff20f61999624e7877692b579f8a8d..3d4c134c4a6822bc50966d7d85e4242a18c359cf 100644
--- a/test/cases/safety/integer negation overflow.zig	
+++ b/test/cases/safety/integer negation overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig
index 6d9380ee26ef9464d3f2922b58347867ff2f4e92..84a16f55b870cac727651d6d68edfa3b18922ac0 100644
--- a/test/cases/safety/integer subtraction overflow.zig	
+++ b/test/cases/safety/integer subtraction overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/invalid resume of async function.zig b/test/cases/safety/invalid resume of async function.zig
index 2ed5704c74bcbb0695d3c0fc032b1ccc53c28c83..c58f13b99d05389a8bf3dd34d98090190593539f 100644
--- a/test/cases/safety/invalid resume of async function.zig	
+++ b/test/cases/safety/invalid resume of async function.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig
index 435570f2fbf09ec21c7ec83b174b644c074b34f1..f201062c0e8fbf988f0814026a66bf71c5d9cc6d 100644
--- a/test/cases/safety/modrem by zero.zig	
+++ b/test/cases/safety/modrem by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig
index 9d57865a87f55207cfbf7c6bf5e5338f1a26ed28..6714458979d01bf8105382ac9903be4ecc11c308 100644
--- a/test/cases/safety/modulus by zero.zig	
+++ b/test/cases/safety/modulus by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/nosuspend function call, callee suspends.zig b/test/cases/safety/nosuspend function call, callee suspends.zig
index 42daa4a9bdcaa511e8dbf441ac70e4051c257642..50f457f31458024c555d3a4c374ffb6e05cd67ac 100644
--- a/test/cases/safety/nosuspend function call, callee suspends.zig	
+++ b/test/cases/safety/nosuspend function call, callee suspends.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/optional unwrap operator on C pointer.zig b/test/cases/safety/optional unwrap operator on C pointer.zig
index 10e605cadd24934096ea38cba3c5b29a37c39932..a4352192337cfaef773a0320cfd163a3bdbfb471 100644
--- a/test/cases/safety/optional unwrap operator on C pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on C pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig
index 3d2991d9ecc329797b57c20b09a948f267736214..5749be9e36bafde0c4188a6464dd2da7449695cf 100644
--- a/test/cases/safety/optional unwrap operator on null pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on null pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig
index ddd9e74cf28565c598f5d04d8007fe2725095ce5..b4c87948a5ce44be34576b64fc0156ac1b3012b5 100644
--- a/test/cases/safety/out of bounds slice access.zig	
+++ b/test/cases/safety/out of bounds slice access.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer casting null to non-optional pointer.zig
index e46b84f7838cc6eed4394d23b0a01daa9890d4af..6ec47f52fb76032f267c254df19595c41da65d77 100644
--- a/test/cases/safety/pointer casting null to non-optional pointer.zig	
+++ b/test/cases/safety/pointer casting null to non-optional pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig
index ec25ec2969e0cf41d719115ac31d99fd26a706a2..3972528edf4251930d01d767a2fb3a85feb9f898 100644
--- a/test/cases/safety/pointer slice sentinel mismatch.zig	
+++ b/test/cases/safety/pointer slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig
index 71e295c4dd6dfd5059c81c85e5851d4753aa68fb..3dc97f6e16fd4ef0d65cabaab77b16c9063dde0e 100644
--- a/test/cases/safety/remainder division by zero.zig	
+++ b/test/cases/safety/remainder division by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/resuming a function which is awaiting a call.zig b/test/cases/safety/resuming a function which is awaiting a call.zig
index b34444150700273cf30ef06396b1a97bb6cb7701..47545584eaf19b95d65c209462fc9fde2896bd3b 100644
--- a/test/cases/safety/resuming a function which is awaiting a call.zig	
+++ b/test/cases/safety/resuming a function which is awaiting a call.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a function which is awaiting a frame.zig b/test/cases/safety/resuming a function which is awaiting a frame.zig
index e63b49183e35f75fd2bddae0afa6eb69cdffb900..26df1ae900b470e279f6aa35a53d96dab9cee0f6 100644
--- a/test/cases/safety/resuming a function which is awaiting a frame.zig	
+++ b/test/cases/safety/resuming a function which is awaiting a frame.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig
index 54de0b9ebdb0d2774ca0eaac948b98d65185aa7a..e03974f08d25692fbe523d3780bd8af6a8bb96e4 100644
--- a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig	
+++ b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a non-suspended function which never been suspended.zig b/test/cases/safety/resuming a non-suspended function which never been suspended.zig
index 8c35753d6d5d88fa9d6339a7da825035cb8347cc..fb3f5aa307f0ca1b085ae08ff928e2c73a15e493 100644
--- a/test/cases/safety/resuming a non-suspended function which never been suspended.zig	
+++ b/test/cases/safety/resuming a non-suspended function which never been suspended.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig
index e786a739d6078920123a205aa2aa76ba873ef2f7..d89f7d4ebef9e0ee5f065895d3ba4f6d7d53ae7e 100644
--- a/test/cases/safety/shift left by huge amount.zig	
+++ b/test/cases/safety/shift left by huge amount.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig
index a45b8c24cebfb0ecf181615728a352a8ebf10379..8107bc17380bb856b73e6e70d7184b4781bfd555 100644
--- a/test/cases/safety/shift right by huge amount.zig	
+++ b/test/cases/safety/shift right by huge amount.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig
index 8bc5be0d630ba0bec1b392ca678405fadd8004b4..53e72e90feefddf9f2f0381ff74eaa37b6aea5d8 100644
--- a/test/cases/safety/signed integer division overflow - vectors.zig	
+++ b/test/cases/safety/signed integer division overflow - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig
index 6d17c284dfc7233e8f5332aeae7205c83fe66385..9d1014ceec08a9fc6db54f4cd42cb9a9ea6359bd 100644
--- a/test/cases/safety/signed integer division overflow.zig	
+++ b/test/cases/safety/signed integer division overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig
index 6ee23c9aeee13a70791386520643f61c6f102f7f..a79298b7da0876f461d5cde21f53b56f7d035819 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig
index 5c21e0a0980b2a28eb1f21c080c2676d700a3809..6c4e9e256d1f6d6efe483de4344c2b5dd84c5c28 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig
index 75e97110328bcbcf913809cb77e9da0c768efdf3..f9a4db81ce92c36f6e1fd84b204d98c7a8724c27 100644
--- a/test/cases/safety/signed shift left overflow.zig	
+++ b/test/cases/safety/signed shift left overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig
index 52c6158a4d06361bc94db4b4845459daf8c3fffd..7d71b9ffbde3cd9d00ef63cde643c0ad88266142 100644
--- a/test/cases/safety/signed shift right overflow.zig	
+++ b/test/cases/safety/signed shift right overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig
index 5d8a2ea2715393c57718ea99592251108f779127..d287c0a1aee81155947189e1a0a63daa4fb826a3 100644
--- a/test/cases/safety/signed-unsigned vector cast.zig	
+++ b/test/cases/safety/signed-unsigned vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig
index 3d08872ca747a50d12db306e754782a03b66a5df..843da93b01913116f0ac5ace1041e78596fab1ad 100644
--- a/test/cases/safety/slice sentinel mismatch - floats.zig	
+++ b/test/cases/safety/slice sentinel mismatch - floats.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.20000004e+00, found 4.0e+00")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
index fbc6fcf42802af988c01ba73d93a4f3fcfccbf4c..6be303d9aad8c112234691b8e09532ec1fab30b4 100644
--- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
+++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig
index b1bca1a11f0db83d0f5af731075a4a0b35bf2be8..635706b2c58a42a8f8f1849a06749020f3399200 100644
--- a/test/cases/safety/slice slice sentinel mismatch.zig	
+++ b/test/cases/safety/slice slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig
index 524c69d7b7dd45934f09cc9eca0c515d88eb7ca1..2f27bebd55c456a75cc040a4f2bf00d4193f9ae3 100644
--- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig
index 636235a5b34cb34d7a0f94b4c943cb12ae4af39a..1683dc9d3f329cae0d0ad2e02124f5b05189ff36 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig
index 276725361235ea4dbc1223fa63d362471e4e9324..eda9de20d29b4d42aa72a3093ae7ec0dc6bec92b 100644
--- a/test/cases/safety/slicing null C pointer - runtime len.zig	
+++ b/test/cases/safety/slicing null C pointer - runtime len.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index f5041adae76faef19ac0b6e73a7da1c63a98b12c..6ef049c6a1cc7cd3fd91b2466fe11c07a295743e 100644
--- a/test/cases/safety/slicing null C pointer.zig	
+++ b/test/cases/safety/slicing null C pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig
index fd94976763c9a61f5bd8126ddbbaf7b42b8cffc6..2240fe0c8e66da67b2a1a70d074588cb6f5d2b78 100644
--- a/test/cases/safety/switch on corrupted enum value.zig	
+++ b/test/cases/safety/switch on corrupted enum value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig
index 059f0dc0427fc39b0e3faf560961f504f2096a24..bfb755514a8444a2d868e5f08f26497cf9661970 100644
--- a/test/cases/safety/switch on corrupted union value.zig	
+++ b/test/cases/safety/switch on corrupted union value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig
index 5985952e022041260bd949ae22c78cdda293aaa3..e81a6e64ef52271cdf1c63b1dde75850eb104a8d 100644
--- a/test/cases/safety/truncating vector cast.zig	
+++ b/test/cases/safety/truncating vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig
index f752016aad6dffafa1ebf766b14f95dac316af8f..492f7958b18b38079dff4cacbca2bef0e1f3bc7a 100644
--- a/test/cases/safety/unreachable.zig
+++ b/test/cases/safety/unreachable.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "reached unreachable code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig
index ca901560f04858f9f8fecaadebe53a747adf5069..f370f76557f48b5f3805071d4d0d0cac9e12ded0 100644
--- a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
+++ b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig
index 9d6b6a3c48c3199e5a466f875a88886488d3b54d..d38d8f6ecf0640578fcb1062cb0f43c020b59c4d 100644
--- a/test/cases/safety/unsigned shift left overflow.zig	
+++ b/test/cases/safety/unsigned shift left overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig
index 500e82866b458f7050f70d365aa3481a83f97011..121797a17d4c6809d62e50d716316a972dec67e1 100644
--- a/test/cases/safety/unsigned shift right overflow.zig	
+++ b/test/cases/safety/unsigned shift right overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig
index eb3995269f721548a0591859fa5fabba28fc99cd..d4b80fb05c2a8c8bbbbdbde74bcaff126ec1e909 100644
--- a/test/cases/safety/unsigned-signed vector cast.zig	
+++ b/test/cases/safety/unsigned-signed vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig
index 1df0253e095abc6b0a0e3fe0a0d0dbfb340f47d2..0723a9fb246a81f4e9ea60e90f339fb191bebf66 100644
--- a/test/cases/safety/unwrap error switch.zig	
+++ b/test/cases/safety/unwrap error switch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig
index 498461976d4961509b3ea3e937b0129119d1c3ef..e2d7ea725b8b50a0797159dc9cf6b07c47eace57 100644
--- a/test/cases/safety/unwrap error.zig	
+++ b/test/cases/safety/unwrap error.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
         std.process.exit(0);
diff --git a/test/cases/safety/value does not fit in shortening cast - u0.zig b/test/cases/safety/value does not fit in shortening cast - u0.zig
index 3ff3aa6e6c74f9f0151b888ad04931afe7446e00..9b303e5cf5c77ae626f1783d6294b8486d98e3d3 100644
--- a/test/cases/safety/value does not fit in shortening cast - u0.zig	
+++ b/test/cases/safety/value does not fit in shortening cast - u0.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/value does not fit in shortening cast.zig b/test/cases/safety/value does not fit in shortening cast.zig
index 510273a57bd626eb92cae6725ef92a7a768e6a10..0e98a0978755bd5d9026a8e49801d8539965ae94 100644
--- a/test/cases/safety/value does not fit in shortening cast.zig	
+++ b/test/cases/safety/value does not fit in shortening cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig
index 7e34fa9393926d89400a2fd4b664673577ebd826..c553b4618937a083c83c3f1008481f039e4bb7c1 100644
--- a/test/cases/safety/vector integer addition overflow.zig	
+++ b/test/cases/safety/vector integer addition overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig
index a2a74072b3b2eed6b737056302e2698028d5c6da..4549f7c3e3578243d89bb9bb77b841afbe004933 100644
--- a/test/cases/safety/vector integer multiplication overflow.zig	
+++ b/test/cases/safety/vector integer multiplication overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig
index 7f59982372073a40d83e0192fc37c909ddbdc7c7..8c2c160c680f96537a5097fdf8637c29e75b02c1 100644
--- a/test/cases/safety/vector integer negation overflow.zig	
+++ b/test/cases/safety/vector integer negation overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig
index dbfee3af1e8a45e70cfadbfd19c2a6da993f0298..bc475d9800dcced84a54e703f20d67604539e311 100644
--- a/test/cases/safety/vector integer subtraction overflow.zig	
+++ b/test/cases/safety/vector integer subtraction overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig
index 3a2edf834a1c7b2c7371c541d5c383cbbbf20a48..c1be6856a7e707ce13a1c09f8f471a1e86307167 100644
--- a/test/cases/safety/zero casted to error.zig	
+++ b/test/cases/safety/zero casted to error.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cli.zig b/test/cli.zig
index 979478c786fe8f361466f119327736044e0814d4..df1a1497e1229f0683c9060ec757927ffaf2cab0 100644
--- a/test/cli.zig
+++ b/test/cli.zig
@@ -120,7 +120,7 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
         \\    return num * num;
         \\}
         \\extern fn zig_panic() noreturn;
-        \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace) noreturn {
+        \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace, _: ?usize) noreturn {
         \\    _ = msg;
         \\    _ = error_return_trace;
         \\    zig_panic();
diff --git a/test/standalone/issue_339/test.zig b/test/standalone/issue_339/test.zig
index 5e0aafc182a84cc5f91f5c0f00fad85921f91c07..e28839209c1988a68fb46c269a32d5d0b311cfd5 100644
--- a/test/standalone/issue_339/test.zig
+++ b/test/standalone/issue_339/test.zig
@@ -1,5 +1,5 @@
 const StackTrace = @import("std").builtin.StackTrace;
-pub fn panic(msg: []const u8, stack_trace: ?*StackTrace) noreturn {
+pub fn panic(msg: []const u8, stack_trace: ?*StackTrace, _: ?usize) noreturn {
     _ = msg;
     _ = stack_trace;
     @breakpoint();
diff --git a/test/standalone/issue_8550/main.zig b/test/standalone/issue_8550/main.zig
index 615e9aed6a1da368169be6016275850b6639d9ec..1f64f03cf22533410b5e1381543723f2694e4716 100644
--- a/test/standalone/issue_8550/main.zig
+++ b/test/standalone/issue_8550/main.zig
@@ -4,7 +4,7 @@ export fn main(r0: u32, r1: u32, atags: u32) callconv(.C) noreturn {
     _ = atags;
     unreachable; // never gets run so it doesn't matter
 }
-pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace, _: ?usize) noreturn {
     _ = msg;
     _ = error_return_trace;
     while (true) {}