std: add return address parameter to panic fn

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) {

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);

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);

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 {

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.

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;
 }

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);
 }

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

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

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'

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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();

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();

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) {}