From 04e694ad116ad2706328c13ce3643347330a861f Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 24 Sep 2024 16:15:06 -0700 Subject: [PATCH 01/21] move std.time.sleep to std.Thread.sleep --- lib/std/Thread.zig | 77 +++++++++++++++++++++++++++++++++++++++++++ lib/std/time.zig | 82 +++------------------------------------------- 2 files changed, 81 insertions(+), 78 deletions(-) diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig index 446b629cc6ec..a5c03138f79a 100644 --- a/lib/std/Thread.zig +++ b/lib/std/Thread.zig @@ -22,6 +22,83 @@ pub const WaitGroup = @import("Thread/WaitGroup.zig"); pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc; +/// Spurious wakeups are possible and no precision of timing is guaranteed. +pub fn sleep(nanoseconds: u64) void { + if (builtin.os.tag == .windows) { + const big_ms_from_ns = nanoseconds / std.time.ns_per_ms; + const ms = math.cast(windows.DWORD, big_ms_from_ns) orelse math.maxInt(windows.DWORD); + windows.kernel32.Sleep(ms); + return; + } + + if (builtin.os.tag == .wasi) { + const w = std.os.wasi; + const userdata: w.userdata_t = 0x0123_45678; + const clock: w.subscription_clock_t = .{ + .id = .MONOTONIC, + .timeout = nanoseconds, + .precision = 0, + .flags = 0, + }; + const in: w.subscription_t = .{ + .userdata = userdata, + .u = .{ + .tag = .CLOCK, + .u = .{ .clock = clock }, + }, + }; + + var event: w.event_t = undefined; + var nevents: usize = undefined; + _ = w.poll_oneoff(&in, &event, 1, &nevents); + return; + } + + if (builtin.os.tag == .uefi) { + const boot_services = std.os.uefi.system_table.boot_services.?; + const us_from_ns = nanoseconds / std.time.ns_per_us; + const us = math.cast(usize, us_from_ns) orelse math.maxInt(usize); + _ = boot_services.stall(us); + return; + } + + const s = nanoseconds / std.time.ns_per_s; + const ns = nanoseconds % std.time.ns_per_s; + + // Newer kernel ports don't have old `nanosleep()` and `clock_nanosleep()` has been around + // since Linux 2.6 and glibc 2.1 anyway. + if (builtin.os.tag == .linux) { + const linux = std.os.linux; + + var req: linux.timespec = .{ + .sec = std.math.cast(linux.time_t, s) orelse std.math.maxInt(linux.time_t), + .nsec = std.math.cast(linux.time_t, ns) orelse std.math.maxInt(linux.time_t), + }; + var rem: linux.timespec = undefined; + + while (true) { + switch (linux.E.init(linux.clock_nanosleep(.MONOTONIC, .{ .ABSTIME = false }, &req, &rem))) { + .SUCCESS => return, + .INTR => { + req = rem; + continue; + }, + .FAULT, + .INVAL, + .OPNOTSUPP, + => unreachable, + else => return, + } + } + } + + posix.nanosleep(s, ns); +} + +test sleep { + sleep(1); +} + const Thread = @This(); const Impl = if (native_os == .windows) WindowsThreadImpl diff --git a/lib/std/time.zig b/lib/std/time.zig index a80a2477acc7..d253b6351270 100644 --- a/lib/std/time.zig +++ b/lib/std/time.zig @@ -8,82 +8,8 @@ const posix = std.posix; pub const epoch = @import("time/epoch.zig"); -/// Spurious wakeups are possible and no precision of timing is guaranteed. -pub fn sleep(nanoseconds: u64) void { - if (builtin.os.tag == .windows) { - const big_ms_from_ns = nanoseconds / ns_per_ms; - const ms = math.cast(windows.DWORD, big_ms_from_ns) orelse math.maxInt(windows.DWORD); - windows.kernel32.Sleep(ms); - return; - } - - if (builtin.os.tag == .wasi) { - const w = std.os.wasi; - const userdata: w.userdata_t = 0x0123_45678; - const clock: w.subscription_clock_t = .{ - .id = .MONOTONIC, - .timeout = nanoseconds, - .precision = 0, - .flags = 0, - }; - const in: w.subscription_t = .{ - .userdata = userdata, - .u = .{ - .tag = .CLOCK, - .u = .{ .clock = clock }, - }, - }; - - var event: w.event_t = undefined; - var nevents: usize = undefined; - _ = w.poll_oneoff(&in, &event, 1, &nevents); - return; - } - - if (builtin.os.tag == .uefi) { - const boot_services = std.os.uefi.system_table.boot_services.?; - const us_from_ns = nanoseconds / ns_per_us; - const us = math.cast(usize, us_from_ns) orelse math.maxInt(usize); - _ = boot_services.stall(us); - return; - } - - const s = nanoseconds / ns_per_s; - const ns = nanoseconds % ns_per_s; - - // Newer kernel ports don't have old `nanosleep()` and `clock_nanosleep()` has been around - // since Linux 2.6 and glibc 2.1 anyway. - if (builtin.os.tag == .linux) { - const linux = std.os.linux; - - var req: linux.timespec = .{ - .sec = std.math.cast(linux.time_t, s) orelse std.math.maxInt(linux.time_t), - .nsec = std.math.cast(linux.time_t, ns) orelse std.math.maxInt(linux.time_t), - }; - var rem: linux.timespec = undefined; - - while (true) { - switch (linux.E.init(linux.clock_nanosleep(.MONOTONIC, .{ .ABSTIME = false }, &req, &rem))) { - .SUCCESS => return, - .INTR => { - req = rem; - continue; - }, - .FAULT, - .INVAL, - .OPNOTSUPP, - => unreachable, - else => return, - } - } - } - - posix.nanosleep(s, ns); -} - -test sleep { - sleep(1); -} +/// Deprecated: moved to std.Thread.sleep +pub const sleep = std.Thread.sleep; /// Get a calendar timestamp, in seconds, relative to UTC 1970-01-01. /// Precision of timing depends on the hardware and operating system. @@ -155,7 +81,7 @@ test milliTimestamp { const margin = ns_per_ms * 50; const time_0 = milliTimestamp(); - sleep(ns_per_ms); + std.Thread.sleep(ns_per_ms); const time_1 = milliTimestamp(); const interval = time_1 - time_0; try testing.expect(interval > 0); @@ -359,7 +285,7 @@ test Timer { const margin = ns_per_ms * 150; var timer = try Timer.start(); - sleep(10 * ns_per_ms); + std.Thread.sleep(10 * ns_per_ms); const time_0 = timer.read(); try testing.expect(time_0 > 0); // Tests should not depend on timings: skip test if outside margin. From 4f8d244e7ea47a8cdb41496d51961ef4ba3ec2af Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 11:11:48 -0700 Subject: [PATCH 02/21] remove formatted panics implements #17969 --- lib/compiler_rt/common.zig | 6 +- lib/std/builtin.zig | 213 +++------- lib/std/debug.zig | 294 ++++++++++--- lib/std/fmt.zig | 12 +- src/Compilation.zig | 8 - src/InternPool.zig | 34 +- src/Sema.zig | 660 ++++++++++++------------------ src/Sema/bitcast.zig | 12 +- src/Type.zig | 4 +- src/Value.zig | 12 +- src/Zcu.zig | 40 +- src/Zcu/PerThread.zig | 12 +- src/crash_report.zig | 48 ++- src/main.zig | 8 +- src/mutable_value.zig | 4 +- src/target.zig | 8 - test/cases/safety/unreachable.zig | 3 +- 17 files changed, 634 insertions(+), 744 deletions(-) diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index a6fd9533790a..8a1055267da5 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -77,11 +77,9 @@ 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, _: ?usize) noreturn { - _ = error_return_trace; +pub fn panic(cause: std.builtin.PanicCause, error_return_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn { if (builtin.is_test) { - @branchHint(.cold); - std.debug.panic("{s}", .{msg}); + std.debug.defaultPanic(cause, error_return_trace, ret_addr orelse @returnAddress()); } else { unreachable; } diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index abbdf89c0a3c..8530a64fedab 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -763,181 +763,66 @@ pub const TestFn = struct { /// 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, ?usize) noreturn; +pub const PanicFn = fn (PanicCause, ?*StackTrace, ?usize) noreturn; -/// This function is used by the Zig language code generation and -/// therefore must be kept in sync with the compiler implementation. +/// The entry point for auto-generated calls by the compiler. pub const panic: PanicFn = if (@hasDecl(root, "panic")) root.panic else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) root.os.panic else - default_panic; + std.debug.defaultPanic; -/// This function is used by the Zig language code generation and +/// This data structure 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, ret_addr: ?usize) noreturn { - @branchHint(.cold); - - // For backends that cannot handle the language features depended on by the - // default panic handler, we have a simpler panic handler: - if (builtin.zig_backend == .stage2_wasm or - builtin.zig_backend == .stage2_arm or - builtin.zig_backend == .stage2_aarch64 or - builtin.zig_backend == .stage2_x86 or - (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or - builtin.zig_backend == .stage2_sparc64 or - builtin.zig_backend == .stage2_spirv64) - { - while (true) { - @breakpoint(); - } - } - - if (builtin.zig_backend == .stage2_riscv64) { - std.debug.print("panic: {s}\n", .{msg}); - @breakpoint(); - std.posix.exit(127); - } - - switch (builtin.os.tag) { - .freestanding => { - while (true) { - @breakpoint(); - } - }, - .wasi => { - std.debug.print("{s}", .{msg}); - std.posix.abort(); - }, - .uefi => { - const uefi = std.os.uefi; - - const Formatter = struct { - pub fn fmt(exit_msg: []const u8, out: []u16) ![:0]u16 { - var u8_buf: [256]u8 = undefined; - const slice = try std.fmt.bufPrint(&u8_buf, "err: {s}\r\n", .{exit_msg}); - // We pass len - 1 because we need to add a null terminator after - const len = try std.unicode.utf8ToUtf16Le(out[0 .. out.len - 1], slice); - - out[len] = 0; - - return out[0..len :0]; - } - }; - - const ExitData = struct { - pub fn create_exit_data(exit_msg: [:0]u16, exit_size: *usize) ![*:0]u16 { - // Need boot services for pool allocation - if (uefi.system_table.boot_services == null) { - return error.BootServicesUnavailable; - } - - // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220) - const exit_data: []u16 = try uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1); - - @memcpy(exit_data[0 .. exit_msg.len + 1], exit_msg[0 .. exit_msg.len + 1]); - exit_size.* = exit_msg.len + 1; - - return @as([*:0]u16, @ptrCast(exit_data.ptr)); - } - }; - - var buf: [256]u16 = undefined; - const utf16 = Formatter.fmt(msg, &buf) catch null; - - var exit_size: usize = 0; - const exit_data = if (utf16) |u| - ExitData.create_exit_data(u, &exit_size) catch null - else - null; - - if (utf16) |str| { - // Output to both std_err and con_out, as std_err is easier - // to read in stuff like QEMU at times, but, unlike con_out, - // isn't visible on actual hardware if directly booted into - inline for ([_]?*uefi.protocol.SimpleTextOutput{ uefi.system_table.std_err, uefi.system_table.con_out }) |o| { - if (o) |out| { - _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red); - _ = out.outputString(str); - _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white); - } - } - } - - if (uefi.system_table.boot_services) |bs| { - _ = bs.exit(uefi.handle, .Aborted, exit_size, exit_data); - } - - // Didn't have boot_services, just fallback to whatever. - std.posix.abort(); - }, - .cuda, .amdhsa => std.posix.abort(), - .plan9 => { - var status: [std.os.plan9.ERRMAX]u8 = undefined; - const len = @min(msg.len, status.len - 1); - @memcpy(status[0..len], msg[0..len]); - status[len] = 0; - std.os.plan9.exits(status[0..len :0]); - }, - else => { - const first_trace_addr = ret_addr orelse @returnAddress(); - std.debug.panicImpl(error_return_trace, first_trace_addr, msg); - }, - } -} - -pub fn panicSentinelMismatch(expected: anytype, actual: @TypeOf(expected)) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ expected, actual }); -} - -pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn { - @branchHint(.cold); - std.debug.panicExtra(st, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)}); -} - -pub fn panicOutOfBounds(index: usize, len: usize) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len }); -} +pub const PanicCause = union(enum) { + reached_unreachable, + unwrap_null, + cast_to_null, + incorrect_alignment, + invalid_error_code, + cast_truncated_data, + negative_to_unsigned, + integer_overflow, + shl_overflow, + shr_overflow, + divide_by_zero, + exact_division_remainder, + inactive_union_field: InactiveUnionField, + integer_part_out_of_bounds, + corrupt_switch, + shift_rhs_too_big, + invalid_enum_value, + sentinel_mismatch_usize: SentinelMismatchUsize, + sentinel_mismatch_other, + unwrap_error: anyerror, + index_out_of_bounds: IndexOutOfBounds, + start_index_greater_than_end: StartIndexGreaterThanEnd, + for_len_mismatch, + memcpy_len_mismatch, + memcpy_alias, + noreturn_returned, + explicit_call: []const u8, + + pub const IndexOutOfBounds = struct { + index: usize, + len: usize, + }; -pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end }); -} + pub const StartIndexGreaterThanEnd = struct { + start: usize, + end: usize, + }; -pub fn panicInactiveUnionField(active: anytype, wanted: @TypeOf(active)) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ @tagName(wanted), @tagName(active) }); -} + pub const SentinelMismatchUsize = struct { + expected: usize, + found: usize, + }; -pub const panic_messages = struct { - pub const unreach = "reached unreachable code"; - pub const unwrap_null = "attempt to use null value"; - pub const cast_to_null = "cast causes pointer to be null"; - pub const incorrect_alignment = "incorrect alignment"; - pub const invalid_error_code = "invalid error code"; - pub const cast_truncated_data = "integer cast truncated bits"; - pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer"; - pub const integer_overflow = "integer overflow"; - pub const shl_overflow = "left shift overflowed bits"; - pub const shr_overflow = "right shift overflowed bits"; - pub const divide_by_zero = "division by zero"; - pub const exact_division_remainder = "exact division produced remainder"; - pub const inactive_union_field = "access of inactive union field"; - pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds"; - pub const corrupt_switch = "switch on corrupt value"; - pub const shift_rhs_too_big = "shift amount is greater than the type size"; - pub const invalid_enum_value = "invalid enum value"; - pub const sentinel_mismatch = "sentinel mismatch"; - pub const unwrap_error = "attempt to unwrap error"; - pub const index_out_of_bounds = "index out of bounds"; - pub const start_index_greater_than_end = "start index is larger than end index"; - pub const for_len_mismatch = "for loop over objects with non-equal lengths"; - pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths"; - pub const memcpy_alias = "@memcpy arguments alias"; - pub const noreturn_returned = "'noreturn' function returned"; + pub const InactiveUnionField = struct { + active: []const u8, + accessed: []const u8, + }; }; pub noinline fn returnError(st: *StackTrace) void { diff --git a/lib/std/debug.zig b/lib/std/debug.zig index fd6676504fb7..8e5498b3f5ba 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -408,14 +408,15 @@ pub fn assertReadable(slice: []const volatile u8) void { for (slice) |*byte| _ = byte.*; } +/// Equivalent to `@panic` but with a formatted message. pub fn panic(comptime format: []const u8, args: anytype) noreturn { @branchHint(.cold); panicExtra(@errorReturnTrace(), @returnAddress(), format, args); } -/// `panicExtra` is useful when you want to print out an `@errorReturnTrace` -/// and also print out some values. +/// Equivalent to `@panic` but with a formatted message, and with an explicitly +/// provided `@errorReturnTrace` and return address. pub fn panicExtra( trace: ?*std.builtin.StackTrace, ret_addr: ?usize, @@ -447,11 +448,104 @@ var panicking = std.atomic.Value(u8).init(0); /// This is used to catch and handle panics triggered by the panic handler. threadlocal var panic_stage: usize = 0; -// `panicImpl` could be useful in implementing a custom panic handler which -// calls the default handler (on supported platforms) -pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn { +// Dumps a stack trace to standard error, then aborts. +// +// This function avoids a dependency on formatted printing. +pub fn defaultPanic( + cause: std.builtin.PanicCause, + trace: ?*const std.builtin.StackTrace, + first_trace_addr: ?usize, +) noreturn { @branchHint(.cold); + // For backends that cannot handle the language features depended on by the + // default panic handler, we have a simpler panic handler: + if (builtin.zig_backend == .stage2_wasm or + builtin.zig_backend == .stage2_arm or + builtin.zig_backend == .stage2_aarch64 or + builtin.zig_backend == .stage2_x86 or + (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or + builtin.zig_backend == .stage2_sparc64 or + builtin.zig_backend == .stage2_spirv64) + { + @trap(); + } + + if (builtin.zig_backend == .stage2_riscv64) { + var buffer: [1000]u8 = undefined; + var i: usize = 0; + i += fmtPanicCause(buffer[i..], cause); + buffer[i] = '\n'; + i += 1; + const msg = buffer[0..i]; + lockStdErr(); + io.getStdErr().writeAll(msg) catch {}; + @trap(); + } + + switch (builtin.os.tag) { + .freestanding => { + @trap(); + }, + .wasi => { + // TODO: before merging my branch, unify this logic with the main panic logic + var buffer: [1000]u8 = undefined; + var i: usize = 0; + i += fmtPanicCause(buffer[i..], cause); + buffer[i] = '\n'; + i += 1; + const msg = buffer[0..i]; + lockStdErr(); + io.getStdErr().writeAll(msg) catch {}; + @trap(); + }, + .uefi => { + const uefi = std.os.uefi; + + var buffer: [1000]u8 = undefined; + var i: usize = 0; + i += fmtBuf(buffer[i..], "panic: "); + i += fmtPanicCause(buffer[i..], cause); + i += fmtBuf(buffer[i..], "\r\n\x00"); + + var utf16_buffer: [1000]u16 = undefined; + const len = std.unicode.utf8ToUtf16Le(&utf16_buffer, buffer[0..i]) catch 0; + const exit_msg = utf16_buffer[0 .. len - 1 :0]; + + // Output to both std_err and con_out, as std_err is easier + // to read in stuff like QEMU at times, but, unlike con_out, + // isn't visible on actual hardware if directly booted into + inline for ([_]?*uefi.protocol.SimpleTextOutput{ uefi.system_table.std_err, uefi.system_table.con_out }) |o| { + if (o) |out| { + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red); + _ = out.outputString(exit_msg); + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white); + } + } + + if (uefi.system_table.boot_services) |bs| { + // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220) + const exit_data: []u16 = uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1) catch @trap(); + @memcpy(exit_data, exit_msg[0..exit_data.len]); // Includes null terminator. + _ = bs.exit(uefi.handle, .Aborted, exit_msg.len + 1, exit_data); + } + @trap(); + }, + .cuda, .amdhsa => std.posix.abort(), + .plan9 => { + var buffer: [1000]u8 = undefined; + comptime assert(buffer.len > std.os.plan9.ERRMAX); + var i: usize = 0; + i += fmtPanicCause(buffer[i..], cause); + buffer[i] = '\n'; + i += 1; + const len = @min(i, std.os.plan9.ERRMAX - 1); + buffer[len] = 0; + std.os.plan9.exits(buffer[0..len :0]); + }, + else => {}, + } + if (enable_segfault_handler) { // If a segfault happens while panicking, we want it to actually segfault, not trigger // the handler. @@ -465,23 +559,29 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize _ = panicking.fetchAdd(1, .seq_cst); - // Make sure to release the mutex when done { - lockStdErr(); - defer unlockStdErr(); - - const stderr = io.getStdErr().writer(); + // This code avoids a dependency on formatted printing, the writer interface, + // and limits to only 1 syscall made to print the panic message to stderr. + var buffer: [0x1000]u8 = undefined; + var i: usize = 0; if (builtin.single_threaded) { - stderr.print("panic: ", .{}) catch posix.abort(); + i += fmtBuf(buffer[i..], "panic: "); } else { - const current_thread_id = std.Thread.getCurrentId(); - stderr.print("thread {} panic: ", .{current_thread_id}) catch posix.abort(); - } - stderr.print("{s}\n", .{msg}) catch posix.abort(); - if (trace) |t| { - dumpStackTrace(t.*); + i += fmtBuf(buffer[i..], "thread "); + i += fmtInt10(buffer[i..], std.Thread.getCurrentId()); + i += fmtBuf(buffer[i..], " panic: "); } - dumpCurrentStackTrace(first_trace_addr); + i += fmtPanicCause(&buffer, cause); + buffer[i] = '\n'; + i += 1; + const msg = buffer[0..i]; + + lockStdErr(); + defer unlockStdErr(); + + io.getStdErr().writeAll(msg) catch posix.abort(); + if (trace) |t| dumpStackTrace(t.*); + dumpCurrentStackTrace(first_trace_addr orelse @returnAddress()); } waitForOtherThreadToFinishPanicking(); @@ -489,20 +589,99 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize 1 => { panic_stage = 2; - // A panic happened while trying to print a previous panic message, - // we're still holding the mutex but that's fine as we're going to - // call abort() - const stderr = io.getStdErr().writer(); - stderr.print("Panicked during a panic. Aborting.\n", .{}) catch posix.abort(); - }, - else => { - // Panicked while printing "Panicked during a panic." + // A panic happened while trying to print a previous panic message. + // We're still holding the mutex but that's fine as we're going to + // call abort(). + io.getStdErr().writeAll("aborting due to recursive panic\n") catch {}; }, + else => {}, // Panicked while printing the recursive panic message. }; posix.abort(); } +pub fn fmtPanicCause(buffer: []u8, cause: std.builtin.PanicCause) usize { + var i: usize = 0; + + switch (cause) { + .reached_unreachable => i += fmtBuf(buffer[i..], "reached unreachable code"), + .unwrap_null => i += fmtBuf(buffer[i..], "attempt to use null value"), + .cast_to_null => i += fmtBuf(buffer[i..], "cast causes pointer to be null"), + .incorrect_alignment => i += fmtBuf(buffer[i..], "incorrect alignment"), + .invalid_error_code => i += fmtBuf(buffer[i..], "invalid error code"), + .cast_truncated_data => i += fmtBuf(buffer[i..], "integer cast truncated bits"), + .negative_to_unsigned => i += fmtBuf(buffer[i..], "attempt to cast negative value to unsigned integer"), + .integer_overflow => i += fmtBuf(buffer[i..], "integer overflow"), + .shl_overflow => i += fmtBuf(buffer[i..], "left shift overflowed bits"), + .shr_overflow => i += fmtBuf(buffer[i..], "right shift overflowed bits"), + .divide_by_zero => i += fmtBuf(buffer[i..], "division by zero"), + .exact_division_remainder => i += fmtBuf(buffer[i..], "exact division produced remainder"), + .inactive_union_field => |info| { + i += fmtBuf(buffer[i..], "access of union field '"); + i += fmtBuf(buffer[i..], info.accessed); + i += fmtBuf(buffer[i..], "' while field '"); + i += fmtBuf(buffer[i..], info.active); + i += fmtBuf(buffer[i..], "' is active"); + }, + .integer_part_out_of_bounds => i += fmtBuf(buffer[i..], "integer part of floating point value out of bounds"), + .corrupt_switch => i += fmtBuf(buffer[i..], "switch on corrupt value"), + .shift_rhs_too_big => i += fmtBuf(buffer[i..], "shift amount is greater than the type size"), + .invalid_enum_value => i += fmtBuf(buffer[i..], "invalid enum value"), + .sentinel_mismatch_usize => |mm| { + i += fmtBuf(buffer[i..], "sentinel mismatch: expected "); + i += fmtInt10(buffer[i..], mm.expected); + i += fmtBuf(buffer[i..], ", found "); + i += fmtInt10(buffer[i..], mm.found); + }, + .sentinel_mismatch_other => i += fmtBuf(buffer[i..], "sentinel mismatch"), + .unwrap_error => |err| { + i += fmtBuf(buffer[i..], "attempt to unwrap error: "); + i += fmtBuf(buffer[i..], @errorName(err)); + }, + .index_out_of_bounds => |oob| { + i += fmtBuf(buffer[i..], "index "); + i += fmtInt10(buffer[i..], oob.index); + i += fmtBuf(buffer[i..], " exceeds length "); + i += fmtInt10(buffer[i..], oob.len); + }, + .start_index_greater_than_end => |oob| { + i += fmtBuf(buffer[i..], "start index "); + i += fmtInt10(buffer[i..], oob.start); + i += fmtBuf(buffer[i..], " exceeds end index "); + i += fmtInt10(buffer[i..], oob.end); + }, + .for_len_mismatch => i += fmtBuf(buffer[i..], "for loop over objects with non-equal lengths"), + .memcpy_len_mismatch => i += fmtBuf(buffer[i..], "@memcpy arguments have non-equal lengths"), + .memcpy_alias => i += fmtBuf(buffer[i..], "@memcpy arguments alias"), + .noreturn_returned => i += fmtBuf(buffer[i..], "'noreturn' function returned"), + .explicit_call => |msg| i += fmtBuf(buffer[i..], msg), + } + + return i; +} + +fn fmtBuf(out_buf: []u8, s: []const u8) usize { + @memcpy(out_buf[0..s.len], s); + return s.len; +} + +fn fmtInt10(out_buf: []u8, integer_value: usize) usize { + var tmp_buf: [50]u8 = undefined; + var i: usize = tmp_buf.len; + var a: usize = integer_value; + + while (true) { + i -= 1; + tmp_buf[i] = '0' + (a % 10); + a /= 10; + if (a == 0) break; + } + + const result = tmp_buf[i..]; + @memcpy(out_buf[0..result.len], result); + return result.len; +} + /// Must be called only after adding 1 to `panicking`. There are three callsites. fn waitForOtherThreadToFinishPanicking() void { if (panicking.fetchSub(1, .seq_cst) != 1) { @@ -1157,7 +1336,7 @@ pub const default_enable_segfault_handler = runtime_safety and have_segfault_han pub fn maybeEnableSegfaultHandler() void { if (enable_segfault_handler) { - std.debug.attachSegfaultHandler(); + attachSegfaultHandler(); } } @@ -1289,46 +1468,29 @@ fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WIN } } -fn handleSegfaultWindowsExtra( - info: *windows.EXCEPTION_POINTERS, - msg: u8, - label: ?[]const u8, -) noreturn { - const exception_address = @intFromPtr(info.ExceptionRecord.ExceptionAddress); - if (windows.CONTEXT != void) { - nosuspend switch (panic_stage) { - 0 => { - panic_stage = 1; - _ = panicking.fetchAdd(1, .seq_cst); - - { - lockStdErr(); - defer unlockStdErr(); - - dumpSegfaultInfoWindows(info, msg, label); - } +fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) noreturn { + comptime assert(windows.CONTEXT != void); + nosuspend switch (panic_stage) { + 0 => { + panic_stage = 1; + _ = panicking.fetchAdd(1, .seq_cst); + + { + lockStdErr(); + defer unlockStdErr(); - waitForOtherThreadToFinishPanicking(); - }, - else => { - // panic mutex already locked dumpSegfaultInfoWindows(info, msg, label); - }, - }; - posix.abort(); - } else { - switch (msg) { - 0 => panicImpl(null, exception_address, "{s}", label.?), - 1 => { - const format_item = "Segmentation fault at address 0x{x}"; - var buf: [format_item.len + 64]u8 = undefined; // 64 is arbitrary, but sufficiently large - const to_print = std.fmt.bufPrint(buf[0..buf.len], format_item, .{info.ExceptionRecord.ExceptionInformation[1]}) catch unreachable; - panicImpl(null, exception_address, to_print); - }, - 2 => panicImpl(null, exception_address, "Illegal Instruction"), - else => unreachable, - } - } + } + + waitForOtherThreadToFinishPanicking(); + }, + 1 => { + panic_stage = 2; + io.getStdErr().writeAll("aborting due to recursive panic\n") catch {}; + }, + else => {}, + }; + posix.abort(); } fn dumpSegfaultInfoWindows(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) void { @@ -1347,7 +1509,7 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void { const sp = asm ("" : [argc] "={rsp}" (-> usize), ); - std.debug.print("{s} sp = 0x{x}\n", .{ prefix, sp }); + print("{s} sp = 0x{x}\n", .{ prefix, sp }); } test "manage resources correctly" { diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig index 12504b687257..123122fd560e 100644 --- a/lib/std/fmt.zig +++ b/lib/std/fmt.zig @@ -1197,7 +1197,7 @@ pub fn formatInt( if (base == 10) { while (a >= 100) : (a = @divTrunc(a, 100)) { index -= 2; - buf[index..][0..2].* = digits2(@as(usize, @intCast(a % 100))); + buf[index..][0..2].* = digits2(@intCast(a % 100)); } if (a < 10) { @@ -1205,13 +1205,13 @@ pub fn formatInt( buf[index] = '0' + @as(u8, @intCast(a)); } else { index -= 2; - buf[index..][0..2].* = digits2(@as(usize, @intCast(a))); + buf[index..][0..2].* = digits2(@intCast(a)); } } else { while (true) { const digit = a % base; index -= 1; - buf[index] = digitToChar(@as(u8, @intCast(digit)), case); + buf[index] = digitToChar(@intCast(digit), case); a /= base; if (a == 0) break; } @@ -1242,11 +1242,7 @@ pub fn formatIntBuf(out_buf: []u8, value: anytype, base: u8, case: Case, options // Converts values in the range [0, 100) to a string. pub fn digits2(value: usize) [2]u8 { - return ("0001020304050607080910111213141516171819" ++ - "2021222324252627282930313233343536373839" ++ - "4041424344454647484950515253545556575859" ++ - "6061626364656667686970717273747576777879" ++ - "8081828384858687888990919293949596979899")[value * 2 ..][0..2].*; + return "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"[value * 2 ..][0..2].*; } const FormatDurationData = struct { diff --git a/src/Compilation.zig b/src/Compilation.zig index 3ca4d376e948..227b6e67efba 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -195,7 +195,6 @@ job_queued_compiler_rt_obj: bool = false, job_queued_fuzzer_lib: bool = false, job_queued_update_builtin_zig: bool, alloc_failure_occurred: bool = false, -formatted_panics: bool = false, last_update_was_cache_hit: bool = false, c_source_files: []const CSourceFile, @@ -1088,7 +1087,6 @@ pub const CreateOptions = struct { /// executable this field is ignored. want_compiler_rt: ?bool = null, want_lto: ?bool = null, - formatted_panics: ?bool = null, function_sections: bool = false, data_sections: bool = false, no_builtin: bool = false, @@ -1357,9 +1355,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil } } - // TODO: https://github.com/ziglang/zig/issues/17969 - const formatted_panics = options.formatted_panics orelse (options.root_mod.optimize_mode == .Debug); - const error_limit = options.error_limit orelse (std.math.maxInt(u16) - 1); // We put everything into the cache hash that *cannot be modified @@ -1520,7 +1515,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil .verbose_link = options.verbose_link, .disable_c_depfile = options.disable_c_depfile, .reference_trace = options.reference_trace, - .formatted_panics = formatted_panics, .time_report = options.time_report, .stack_report = options.stack_report, .test_filters = options.test_filters, @@ -1638,7 +1632,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil hash.addListOfBytes(options.test_filters); hash.addOptionalBytes(options.test_name_prefix); hash.add(options.skip_linker_dependencies); - hash.add(formatted_panics); hash.add(options.emit_h != null); hash.add(error_limit); @@ -2564,7 +2557,6 @@ fn addNonIncrementalStuffToCacheManifest( man.hash.addListOfBytes(comp.test_filters); man.hash.addOptionalBytes(comp.test_name_prefix); man.hash.add(comp.skip_linker_dependencies); - man.hash.add(comp.formatted_panics); //man.hash.add(mod.emit_h != null); man.hash.add(mod.error_limit); } else { diff --git a/src/InternPool.zig b/src/InternPool.zig index 6b20f79561af..f41f780e0a1a 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -7353,6 +7353,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All .func_type => unreachable, // use getFuncType() instead .@"extern" => unreachable, // use getExtern() instead .func => unreachable, // use getFuncInstance() or getFuncDecl() instead + .un => unreachable, // use getUnion instead .variable => |variable| { const has_init = variable.init != .none; @@ -7968,15 +7969,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All if (sentinel != .none) extra.appendAssumeCapacity(.{@intFromEnum(sentinel)}); }, - .un => |un| { - assert(un.ty != .none); - assert(un.val != .none); - items.appendAssumeCapacity(.{ - .tag = .union_value, - .data = try addExtra(extra, un), - }); - }, - .memoized_call => |memoized_call| { for (memoized_call.arg_values) |arg| assert(arg != .none); try extra.ensureUnusedCapacity(@typeInfo(MemoizedCall).@"struct".fields.len + @@ -7996,6 +7988,30 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All return gop.put(); } +pub fn getUnion( + ip: *InternPool, + gpa: Allocator, + tid: Zcu.PerThread.Id, + un: Key.Union, +) Allocator.Error!Index { + var gop = try ip.getOrPutKey(gpa, tid, .{ .un = un }); + defer gop.deinit(); + if (gop == .existing) return gop.existing; + const local = ip.getLocal(tid); + const items = local.getMutableItems(gpa); + const extra = local.getMutableExtra(gpa); + try items.ensureUnusedCapacity(1); + + assert(un.ty != .none); + assert(un.val != .none); + items.appendAssumeCapacity(.{ + .tag = .union_value, + .data = try addExtra(extra, un), + }); + + return gop.put(); +} + pub const UnionTypeInit = struct { flags: packed struct { runtime_tag: LoadedUnionType.RuntimeTag, diff --git a/src/Sema.zig b/src/Sema.zig index 406dbebc313a..a2d883a04067 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -4854,11 +4854,11 @@ fn validateUnionInit( } block.instructions.shrinkRetainingCapacity(block_index); - const union_val = try pt.intern(.{ .un = .{ + const union_val = try pt.internUnion(.{ .ty = union_ty.toIntern(), .tag = tag_val.toIntern(), .val = val.toIntern(), - } }); + }); const union_init = Air.internedToRef(union_val); try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store); return; @@ -5830,8 +5830,6 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const src = block.nodeOffset(inst_data.src_node); const msg_inst = try sema.resolveInst(inst_data.operand); - // `panicWithMsg` would perform this coercion for us, but we can get a better - // source location if we do it here. const coerced_msg = try sema.coerce(block, Type.slice_const_u8, msg_inst, block.builtinCallArgSrc(inst_data.src_node, 0)); if (block.is_comptime) { @@ -5844,7 +5842,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void sema.branch_hint = .cold; } - try sema.panicWithMsg(block, src, coerced_msg, .@"@panic"); + try callPanic(sema, block, src, .explicit_call, coerced_msg, .@"@panic"); } fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -7325,6 +7323,31 @@ fn callBuiltin( ); } +const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?; + +fn callPanic( + sema: *Sema, + block: *Block, + call_src: LazySrcLoc, + tag: PanicCauseTag, + payload: Air.Inst.Ref, + call_operation: CallOperation, +) !void { + const pt = sema.pt; + if (!pt.zcu.backendSupportsFeature(.panic_fn)) { + _ = try block.addNoOp(.trap); + return; + } + const panic_cause_ty = try pt.getBuiltinType("PanicCause"); + const panic_cause = try block.addUnionInit(panic_cause_ty, @intFromEnum(tag), payload); + const panic_fn = try pt.getBuiltin("panic"); + const err_return_trace = try sema.getErrorReturnTrace(block); + const opt_usize_ty = try pt.optionalType(.usize_type); + const null_usize = try pt.nullValue(opt_usize_ty); + const args: [3]Air.Inst.Ref = .{ panic_cause, err_return_trace, Air.internedToRef(null_usize) }; + try sema.callBuiltin(block, call_src, panic_fn, .auto, &args, call_operation); +} + const CallOperation = enum { call, @"@call", @@ -9327,7 +9350,7 @@ fn analyzeErrUnionPayload( if (safety_check and block.wantSafety() and !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) { - try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err); + try sema.addSafetyCheckUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err); } return block.addTyOp(.unwrap_errunion_payload, payload_ty, operand); @@ -9411,7 +9434,7 @@ fn analyzeErrUnionPayloadPtr( if (safety_check and block.wantSafety() and !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) { - try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr); + try sema.addSafetyCheckUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr); } if (initializing) { @@ -14190,7 +14213,6 @@ fn maybeErrorUnwrap( ) !bool { const pt = sema.pt; const zcu = pt.zcu; - if (!zcu.backendSupportsFeature(.panic_unwrap_error)) return false; const tags = sema.code.instructions.items(.tag); for (body) |inst| { @@ -14223,25 +14245,13 @@ fn maybeErrorUnwrap( .as_node => try sema.zirAsNode(block, inst), .field_val => try sema.zirFieldVal(block, inst), .@"unreachable" => { - if (!zcu.comp.formatted_panics) { - try sema.safetyPanic(block, operand_src, .unwrap_error); - return true; - } - - const panic_fn = try pt.getBuiltin("panicUnwrapError"); - const err_return_trace = try sema.getErrorReturnTrace(block); - const args: [2]Air.Inst.Ref = .{ err_return_trace, operand }; - try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); + try callPanic(sema, block, operand_src, .unwrap_error, operand, .@"safety check"); return true; }, .panic => { const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = try sema.resolveInst(inst_data.operand); - - const panic_fn = try pt.getBuiltin("panic"); - const err_return_trace = try sema.getErrorReturnTrace(block); - const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; - try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); + try callPanic(sema, block, operand_src, .explicit_call, msg_inst, .@"@panic"); return true; }, else => unreachable, @@ -17388,9 +17398,6 @@ fn analyzeArithmetic( if (block.wantSafety() and want_safety and scalar_tag == .int) { if (zcu.backendSupportsFeature(.safety_checked_instructions)) { - if (air_tag != air_tag_safe) { - _ = try sema.preparePanicId(block, src, .integer_overflow); - } return block.addBinOp(air_tag_safe, casted_lhs, casted_rhs); } else { const maybe_op_ov: ?Air.Inst.Tag = switch (air_tag) { @@ -18319,29 +18326,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .undefined, .null, .enum_literal, - => |type_info_tag| return Air.internedToRef((try pt.intern(.{ .un = .{ + => |type_info_tag| return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(type_info_tag))).toIntern(), .val = .void_value, - } }))), + }))), .@"fn" => { - const fn_info_nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Fn", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, fn_info_nav); - const fn_info_ty = Type.fromInterned(ip.getNav(fn_info_nav).status.resolved.val); - - const param_info_nav = try sema.namespaceLookup( - block, - src, - fn_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Param", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, param_info_nav); - const param_info_ty = Type.fromInterned(ip.getNav(param_info_nav).status.resolved.val); + const fn_info_ty = try getInnerType(sema, block, src, type_info_ty, "Fn"); + const param_info_ty = try getInnerType(sema, block, src, fn_info_ty, "Param"); const func_ty_info = zcu.typeToFunc(ty).?; const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); @@ -18425,25 +18417,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // args: []const Fn.Param, args_val, }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"fn"))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = fn_info_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .int => { - const int_info_nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Int", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, int_info_nav); - const int_info_ty = Type.fromInterned(ip.getNav(int_info_nav).status.resolved.val); - + const int_info_ty = try getInnerType(sema, block, src, type_info_ty, "Int"); const signedness_ty = try pt.getBuiltinType("Signedness"); const info = ty.intInfo(zcu); const field_values = .{ @@ -18452,37 +18436,30 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // bits: u16, (try pt.intValue(Type.u16, info.bits)).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.int))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = int_info_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .float => { - const float_info_nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Float", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, float_info_nav); - const float_info_ty = Type.fromInterned(ip.getNav(float_info_nav).status.resolved.val); + const float_info_ty = try getInnerType(sema, block, src, type_info_ty, "Float"); const field_vals = .{ // bits: u16, (try pt.intValue(Type.u16, ty.bitSize(zcu))).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.float))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = float_info_ty.toIntern(), .storage = .{ .elems = &field_vals }, } }), - } }))); + }))); }, .pointer => { const info = ty.ptrInfo(zcu); @@ -18492,26 +18469,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai try Type.fromInterned(info.child).lazyAbiAlignment(pt); const addrspace_ty = try pt.getBuiltinType("AddressSpace"); - const pointer_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Pointer", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; - const ptr_size_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - pointer_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Size", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const pointer_ty = try getInnerType(sema, block, src, type_info_ty, "Pointer"); + const ptr_size_ty = try getInnerType(sema, block, src, pointer_ty, "Size"); const field_values = .{ // size: Size, @@ -18534,26 +18493,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai else => Value.fromInterned(info.sentinel), })).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.pointer))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = pointer_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .array => { - const array_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Array", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const array_field_ty = try getInnerType(sema, block, src, type_info_ty, "Array"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -18564,26 +18514,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // sentinel: ?*const anyopaque, (try sema.optRefValue(info.sentinel)).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.array))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = array_field_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .vector => { - const vector_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Vector", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const vector_field_ty = try getInnerType(sema, block, src, type_info_ty, "Vector"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -18592,52 +18533,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // child: type, info.elem_type.toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.vector))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = vector_field_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .optional => { - const optional_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Optional", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const optional_field_ty = try getInnerType(sema, block, src, type_info_ty, "Optional"); const field_values = .{ // child: type, ty.optionalChild(zcu).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.optional))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = optional_field_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .error_set => { // Get the Error type - const error_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Error", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const error_field_ty = try getInnerType(sema, block, src, type_info_ty, "Error"); // Build our list of Error values // Optional value is only null if anyerror @@ -18726,23 +18649,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } }); // Construct Type{ .error_set = errors_val } - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_set))).toIntern(), .val = errors_val, - } }))); + }))); }, .error_union => { - const error_union_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "ErrorUnion", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const error_union_field_ty = try getInnerType(sema, block, src, type_info_ty, "ErrorUnion"); const field_values = .{ // error_set: type, @@ -18750,28 +18664,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // payload: type, ty.errorUnionPayload(zcu).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_union))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = error_union_field_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .@"enum" => { const is_exhaustive = Value.makeBool(ip.loadEnumType(ty.toIntern()).tag_mode != .nonexhaustive); - const enum_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "EnumField", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const enum_field_ty = try getInnerType(sema, block, src, type_info_ty, "EnumField"); const enum_field_vals = try sema.arena.alloc(InternPool.Index, ip.loadEnumType(ty.toIntern()).names.len); for (enum_field_vals, 0..) |*field_val, tag_index| { @@ -18858,16 +18763,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.loadEnumType(ty.toIntern()).namespace.toOptional()); - const type_enum_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Enum", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const type_enum_ty = try getInnerType(sema, block, src, type_info_ty, "Enum"); const field_values = .{ // tag_type: type, @@ -18879,37 +18775,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // is_exhaustive: bool, is_exhaustive.toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"enum"))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = type_enum_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .@"union" => { - const type_union_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Union", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; - - const union_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "UnionField", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const type_union_ty = try getInnerType(sema, block, src, type_info_ty, "Union"); + const union_field_ty = try getInnerType(sema, block, src, type_info_ty, "UnionField"); try ty.resolveLayout(pt); // Getting alignment requires type layout const union_obj = zcu.typeToUnion(ty).?; @@ -19004,16 +18881,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .val = if (ty.unionTagType(zcu)) |tag_ty| tag_ty.toIntern() else .none, } }); - const container_layout_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const container_layout_ty = try getBuiltinInnerType(sema, block, src, "Type", "ContainerLayout"); const field_values = .{ // layout: ContainerLayout, @@ -19026,37 +18894,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // decls: []const Declaration, decls_val, }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"union"))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = type_union_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .@"struct" => { - const type_struct_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Struct", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; - - const struct_field_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "StructField", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const type_struct_ty = try getInnerType(sema, block, src, type_info_ty, "Struct"); + const struct_field_ty = try getInnerType(sema, block, src, type_info_ty, "StructField"); try ty.resolveLayout(pt); // Getting alignment requires type layout @@ -19233,16 +19082,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } else .none, } }); - const container_layout_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const container_layout_ty = try getInnerType(sema, block, src, type_info_ty, "ContainerLayout"); const layout = ty.containerLayout(zcu); @@ -19258,26 +19098,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // is_tuple: bool, Value.makeBool(ty.isTuple(zcu)).toIntern(), }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"struct"))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = type_struct_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .@"opaque" => { - const type_opaque_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Opaque", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const type_opaque_ty = try getInnerType(sema, block, src, type_info_ty, "Opaque"); try ty.resolveFields(pt); const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(zcu)); @@ -19286,14 +19117,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // decls: []const Declaration, decls_val, }; - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"opaque"))).toIntern(), .val = try pt.intern(.{ .aggregate = .{ .ty = type_opaque_ty.toIntern(), .storage = .{ .elems = &field_values }, } }), - } }))); + }))); }, .frame => return sema.failWithUseOfAsync(block, src), .@"anyframe" => return sema.failWithUseOfAsync(block, src), @@ -19309,19 +19140,9 @@ fn typeInfoDecls( ) CompileError!InternPool.Index { const pt = sema.pt; const zcu = pt.zcu; - const ip = &zcu.intern_pool; const gpa = sema.gpa; - const declaration_ty = t: { - const nav = try sema.namespaceLookup( - block, - src, - type_info_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, "Declaration", .no_embedded_nulls), - ) orelse @panic("std.builtin.Type is corrupt"); - try sema.ensureNavResolved(src, nav); - break :t Type.fromInterned(ip.getNav(nav).status.resolved.val); - }; + const declaration_ty = try getInnerType(sema, block, src, type_info_ty, "Declaration"); var decl_vals = std.ArrayList(InternPool.Index).init(gpa); defer decl_vals.deinit(); @@ -20809,11 +20630,11 @@ fn unionInit( if (try sema.resolveValue(init)) |init_val| { const tag_ty = union_ty.unionTagTypeHypothetical(zcu); const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index); - return Air.internedToRef((try pt.intern(.{ .un = .{ + return Air.internedToRef((try pt.internUnion(.{ .ty = union_ty.toIntern(), .tag = tag_val.toIntern(), .val = init_val.toIntern(), - } }))); + }))); } try sema.requireRuntimeBlock(block, init_src, null); @@ -20949,11 +20770,11 @@ fn zirStructInit( const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src); if (try sema.resolveValue(init_inst)) |val| { - const struct_val = Value.fromInterned(try pt.intern(.{ .un = .{ + const struct_val = Value.fromInterned(try pt.internUnion(.{ .ty = resolved_ty.toIntern(), .tag = tag_val.toIntern(), .val = val.toIntern(), - } })); + })); const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src); const final_val = (try sema.resolveValue(final_val_inst)).?; return sema.addConstantMaybeRef(final_val.toIntern(), is_ref); @@ -21869,11 +21690,20 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const src = block.nodeOffset(inst_data.src_node); const operand = try sema.resolveInst(inst_data.operand); + return analyzeTagName(sema, block, src, operand_src, operand); +} + +fn analyzeTagName( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + operand_src: LazySrcLoc, + operand: Air.Inst.Ref, +) CompileError!Air.Inst.Ref { const operand_ty = sema.typeOf(operand); const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - try operand_ty.resolveLayout(pt); const enum_ty = switch (operand_ty.zigTypeTag(zcu)) { .enum_literal => { @@ -27840,7 +27670,7 @@ fn explainWhyTypeIsNotPacked( } } -fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { +fn preparePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { const pt = sema.pt; const zcu = pt.zcu; @@ -27871,33 +27701,12 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { .val = .none, } }); } -} - -/// Backends depend on panic decls being available when lowering safety-checked -/// instructions. This function ensures the panic function will be available to -/// be called during that time. -fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) !InternPool.Nav.Index { - const pt = sema.pt; - const zcu = pt.zcu; - const gpa = sema.gpa; - if (zcu.panic_messages[@intFromEnum(panic_id)].unwrap()) |x| return x; - - try sema.prepareSimplePanic(block, src); - const panic_messages_ty = try pt.getBuiltinType("panic_messages"); - const msg_nav_index = (sema.namespaceLookup( - block, - LazySrcLoc.unneeded, - panic_messages_ty.getNamespaceIndex(zcu), - try zcu.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls), - ) catch |err| switch (err) { - error.AnalysisFail => @panic("std.builtin.panic_messages is corrupt"), - error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable, - error.OutOfMemory => |e| return e, - }).?; - try sema.ensureNavResolved(src, msg_nav_index); - zcu.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional(); - return msg_nav_index; + if (zcu.panic_cause_type == .none) { + const panic_cause_ty = try pt.getBuiltinType("PanicCause"); + try panic_cause_ty.resolveFields(pt); + zcu.panic_cause_type = panic_cause_ty.toIntern(); + } } fn addSafetyCheck( @@ -27905,7 +27714,7 @@ fn addSafetyCheck( parent_block: *Block, src: LazySrcLoc, ok: Air.Inst.Ref, - panic_id: Zcu.PanicId, + panic_cause_tag: PanicCauseTag, ) !void { const gpa = sema.gpa; assert(!parent_block.is_comptime); @@ -27923,7 +27732,7 @@ fn addSafetyCheck( defer fail_block.instructions.deinit(gpa); - try sema.safetyPanic(&fail_block, src, panic_id); + try sema.safetyPanic(&fail_block, src, panic_cause_tag); try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } @@ -27992,30 +27801,7 @@ fn addSafetyCheckExtra( parent_block.instructions.appendAssumeCapacity(block_inst); } -fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.Ref, operation: CallOperation) !void { - const pt = sema.pt; - const zcu = pt.zcu; - - if (!zcu.backendSupportsFeature(.panic_fn)) { - _ = try block.addNoOp(.trap); - return; - } - - try sema.prepareSimplePanic(block, src); - - const panic_func = zcu.funcInfo(zcu.panic_func_index); - const panic_fn = try sema.analyzeNavVal(block, src, panic_func.owner_nav); - const null_stack_trace = Air.internedToRef(zcu.null_stack_trace); - - const opt_usize_ty = try pt.optionalType(.usize_type); - const null_ret_addr = Air.internedToRef((try pt.intern(.{ .opt = .{ - .ty = opt_usize_ty.toIntern(), - .val = .none, - } }))); - try sema.callBuiltin(block, src, panic_fn, .auto, &.{ msg_inst, null_stack_trace, null_ret_addr }, operation); -} - -fn panicUnwrapError( +fn addSafetyCheckUnwrapError( sema: *Sema, parent_block: *Block, src: LazySrcLoc, @@ -28023,12 +27809,8 @@ fn panicUnwrapError( unwrap_err_tag: Air.Inst.Tag, is_non_err_tag: Air.Inst.Tag, ) !void { - const pt = sema.pt; assert(!parent_block.is_comptime); const ok = try parent_block.addUnOp(is_non_err_tag, operand); - if (!pt.zcu.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .unwrap_error); - } const gpa = sema.gpa; var fail_block: Block = .{ @@ -28044,21 +27826,13 @@ fn panicUnwrapError( defer fail_block.instructions.deinit(gpa); - { - if (!pt.zcu.backendSupportsFeature(.panic_unwrap_error)) { - _ = try fail_block.addNoOp(.trap); - } else { - const panic_fn = try sema.pt.getBuiltin("panicUnwrapError"); - const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); - const err_return_trace = try sema.getErrorReturnTrace(&fail_block); - const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; - try sema.callBuiltin(&fail_block, src, panic_fn, .auto, &args, .@"safety check"); - } - } + const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); + try callPanic(sema, &fail_block, src, .unwrap_error, err, .@"safety check"); + try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } -fn panicIndexOutOfBounds( +fn addSafetyCheckIndexOob( sema: *Sema, parent_block: *Block, src: LazySrcLoc, @@ -28067,14 +27841,71 @@ fn panicIndexOutOfBounds( cmp_op: Air.Inst.Tag, ) !void { assert(!parent_block.is_comptime); + const gpa = sema.gpa; const ok = try parent_block.addBinOp(cmp_op, index, len); - if (!sema.pt.zcu.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .index_out_of_bounds); + + var fail_block: Block = .{ + .parent = parent_block, + .sema = sema, + .namespace = parent_block.namespace, + .instructions = .{}, + .inlining = parent_block.inlining, + .is_comptime = false, + .src_base_inst = parent_block.src_base_inst, + .type_name_ctx = parent_block.type_name_ctx, + }; + + defer fail_block.instructions.deinit(gpa); + + const oob_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "IndexOutOfBounds"); + comptime { + const fields = @typeInfo(std.builtin.PanicCause.IndexOutOfBounds).@"struct".fields; + assert(std.mem.eql(u8, fields[0].name, "index")); + assert(std.mem.eql(u8, fields[1].name, "len")); + assert(fields.len == 2); } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicOutOfBounds", &.{ index, len }); + const panic_cause_payload = try fail_block.addAggregateInit(oob_ty, &.{ index, len }); + try callPanic(sema, &fail_block, src, .index_out_of_bounds, panic_cause_payload, .@"safety check"); + try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } -fn panicInactiveUnionField( +fn addSafetyCheckStartGreaterThanEnd( + sema: *Sema, + parent_block: *Block, + src: LazySrcLoc, + start: Air.Inst.Ref, + end: Air.Inst.Ref, +) !void { + assert(!parent_block.is_comptime); + const gpa = sema.gpa; + const ok = try parent_block.addBinOp(.cmp_lte, start, end); + + var fail_block: Block = .{ + .parent = parent_block, + .sema = sema, + .namespace = parent_block.namespace, + .instructions = .{}, + .inlining = parent_block.inlining, + .is_comptime = false, + .src_base_inst = parent_block.src_base_inst, + .type_name_ctx = parent_block.type_name_ctx, + }; + + defer fail_block.instructions.deinit(gpa); + + const oob_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "StartIndexGreaterThanEnd"); + comptime { + const fields = @typeInfo(std.builtin.PanicCause.StartIndexGreaterThanEnd).@"struct".fields; + assert(std.mem.eql(u8, fields[0].name, "start")); + assert(std.mem.eql(u8, fields[1].name, "end")); + assert(fields.len == 2); + } + const panic_cause_payload = try fail_block.addAggregateInit(oob_ty, &.{ start, end }); + try callPanic(sema, &fail_block, src, .start_index_greater_than_end, panic_cause_payload, .@"safety check"); + try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); +} + +fn addSafetyCheckInactiveUnionField( sema: *Sema, parent_block: *Block, src: LazySrcLoc, @@ -28082,14 +27913,39 @@ fn panicInactiveUnionField( wanted_tag: Air.Inst.Ref, ) !void { assert(!parent_block.is_comptime); + const gpa = sema.gpa; const ok = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag); - if (!sema.pt.zcu.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .inactive_union_field); - } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicInactiveUnionField", &.{ active_tag, wanted_tag }); + + var fail_block: Block = .{ + .parent = parent_block, + .sema = sema, + .namespace = parent_block.namespace, + .instructions = .{}, + .inlining = parent_block.inlining, + .is_comptime = false, + .src_base_inst = parent_block.src_base_inst, + .type_name_ctx = parent_block.type_name_ctx, + }; + + defer fail_block.instructions.deinit(gpa); + + const payload_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "InactiveUnionField"); + comptime { + const fields = @typeInfo(std.builtin.PanicCause.InactiveUnionField).@"struct".fields; + assert(std.mem.eql(u8, fields[0].name, "active")); + assert(std.mem.eql(u8, fields[1].name, "accessed")); + assert(fields.len == 2); + } + // TODO: before merging the branch, check how many safety checks end up being emitted + // for union field accesses and avoid extraneous ones. + const active_str = try analyzeTagName(sema, &fail_block, src, src, active_tag); + const accessed_str = try analyzeTagName(sema, &fail_block, src, src, wanted_tag); + const panic_cause_payload = try fail_block.addAggregateInit(payload_ty, &.{ active_str, accessed_str }); + try callPanic(sema, &fail_block, src, .inactive_union_field, panic_cause_payload, .@"safety check"); + try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } -fn panicSentinelMismatch( +fn addSafetyCheckSentinelMismatch( sema: *Sema, parent_block: *Block, src: LazySrcLoc, @@ -28099,6 +27955,7 @@ fn panicSentinelMismatch( sentinel_index: Air.Inst.Ref, ) !void { assert(!parent_block.is_comptime); + const gpa = sema.gpa; const pt = sema.pt; const zcu = pt.zcu; const expected_sentinel_val = maybe_sentinel orelse return; @@ -28114,8 +27971,7 @@ fn panicSentinelMismatch( }; const ok = if (sentinel_ty.zigTypeTag(zcu) == .vector) ok: { - const eql = - try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq); + const eql = try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq); break :ok try parent_block.addInst(.{ .tag = .reduce, .data = .{ .reduce = .{ @@ -28128,25 +27984,6 @@ fn panicSentinelMismatch( break :ok try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel); }; - if (!pt.zcu.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .sentinel_mismatch); - } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicSentinelMismatch", &.{ expected_sentinel, actual_sentinel }); -} - -fn safetyCheckFormatted( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - ok: Air.Inst.Ref, - func: []const u8, - args: []const Air.Inst.Ref, -) CompileError!void { - const pt = sema.pt; - const zcu = pt.zcu; - assert(zcu.comp.formatted_panics); - const gpa = sema.gpa; - var fail_block: Block = .{ .parent = parent_block, .sema = sema, @@ -28160,20 +27997,29 @@ fn safetyCheckFormatted( defer fail_block.instructions.deinit(gpa); - if (!zcu.backendSupportsFeature(.safety_check_formatted)) { - _ = try fail_block.addNoOp(.trap); + // A different PanicCause tag must be used depending on what payload type it can be fit into. + // If it cannot fit into any, the "other" tag can be used, which does not try to carry the + // sentinel value data. + + if (sentinel_ty.isUnsignedInt(zcu) and sentinel_ty.intInfo(zcu).bits <= Type.usize.intInfo(zcu).bits) { + const mm_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "SentinelMismatchUsize"); + comptime { + const fields = @typeInfo(std.builtin.PanicCause.SentinelMismatchUsize).@"struct".fields; + assert(std.mem.eql(u8, fields[0].name, "expected")); + assert(std.mem.eql(u8, fields[1].name, "found")); + assert(fields.len == 2); + } + const panic_cause_payload = &fail_block.addAggregateInit(mm_ty, &.{ expected_sentinel, actual_sentinel }); + try callPanic(sema, &fail_block, src, .sentinel_mismatch_usize, panic_cause_payload, .@"safety check"); } else { - const panic_fn = try pt.getBuiltin(func); - try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); + try callPanic(sema, &fail_block, src, .sentinel_mismatch_other, .void_value, .@"safety check"); } try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } /// This does not set `sema.branch_hint`. -fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) CompileError!void { - const msg_nav_index = try sema.preparePanicId(block, src, panic_id); - const msg_inst = try sema.analyzeNavVal(block, src, msg_nav_index); - try sema.panicWithMsg(block, src, msg_inst, .@"safety check"); +fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_cause_tag: PanicCauseTag) CompileError!void { + try callPanic(sema, block, src, panic_cause_tag, .void_value, .@"safety check"); } fn emitBackwardBranch(sema: *Sema, block: *Block, src: LazySrcLoc) !void { @@ -29229,7 +29075,7 @@ fn unionFieldPtr( // TODO would it be better if get_union_tag supported pointers to unions? const union_val = try block.addTyOp(.load, union_ty, union_ptr); const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_val); - try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag); + try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag); } if (field_ty.zigTypeTag(zcu) == .noreturn) { _ = try block.addNoOp(.unreach); @@ -29304,7 +29150,7 @@ fn unionFieldVal( const wanted_tag_val = try pt.enumValueFieldIndex(Type.fromInterned(union_obj.enum_tag_ty), enum_field_index); const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern()); const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_byval); - try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag); + try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag); } if (field_ty.zigTypeTag(zcu) == .noreturn) { _ = try block.addNoOp(.unreach); @@ -29668,11 +29514,11 @@ fn elemValArray( const runtime_src = if (maybe_undef_array_val != null) elem_index_src else array_src; if (oob_safety and block.wantSafety()) { - // Runtime check is only needed if unable to comptime check + // Runtime check is only needed if unable to comptime check. if (maybe_index_val == null) { const len_inst = try pt.intRef(Type.usize, array_len); const cmp_op: Air.Inst.Tag = if (array_sent != null) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op); } } @@ -29740,7 +29586,7 @@ fn elemPtrArray( if (oob_safety and block.wantSafety() and offset == null) { const len_inst = try pt.intRef(Type.usize, array_len); const cmp_op: Air.Inst.Tag = if (array_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op); } return block.addPtrElemPtr(array_ptr, elem_index, elem_ptr_ty); @@ -29799,7 +29645,7 @@ fn elemValSlice( else try block.addTyOp(.slice_len, Type.usize, slice); const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op); } return block.addBinOp(.slice_elem_val, slice, elem_index); } @@ -29859,7 +29705,7 @@ fn elemPtrSlice( break :len try block.addTyOp(.slice_len, Type.usize, slice); }; const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op); } return block.addSliceElemPtr(slice, elem_index, elem_ptr_ty); } @@ -33666,12 +33512,7 @@ fn analyzeSlice( // requirement: start <= end assert(!block.is_comptime); try sema.requireRuntimeBlock(block, src, runtime_src.?); - const ok = try block.addBinOp(.cmp_lte, start, end); - if (!pt.zcu.comp.formatted_panics) { - try sema.addSafetyCheck(block, src, ok, .start_index_greater_than_end); - } else { - try sema.safetyCheckFormatted(block, src, ok, "panicStartGreaterThanEnd", &.{ start, end }); - } + try sema.addSafetyCheckStartGreaterThanEnd(block, src, start, end); } const new_len = if (by_length) try sema.coerce(block, Type.usize, uncasted_end_opt, end_src) @@ -33726,11 +33567,11 @@ fn analyzeSlice( else end; - try sema.panicIndexOutOfBounds(block, src, actual_end, actual_len, .cmp_lte); + try sema.addSafetyCheckIndexOob(block, src, actual_end, actual_len, .cmp_lte); } // requirement: result[new_len] == slice_sentinel - try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); + try sema.addSafetyCheckSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); } return result; }; @@ -33789,11 +33630,11 @@ fn analyzeSlice( try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src, true) else end; - try sema.panicIndexOutOfBounds(block, src, actual_end, len_inst, .cmp_lte); + try sema.addSafetyCheckIndexOob(block, src, actual_end, len_inst, .cmp_lte); } // requirement: start <= end - try sema.panicIndexOutOfBounds(block, src, start, end, .cmp_lte); + try sema.addSafetyCheckIndexOob(block, src, start, end, .cmp_lte); } const result = try block.addInst(.{ .tag = .slice, @@ -33807,7 +33648,7 @@ fn analyzeSlice( }); if (block.wantSafety()) { // requirement: result[new_len] == slice_sentinel - try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); + try sema.addSafetyCheckSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); } return result; } @@ -37688,11 +37529,11 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value { const only_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[0]); const val_val = (try sema.typeHasOnePossibleValue(only_field_ty)) orelse return null; - const only = try pt.intern(.{ .un = .{ + const only = try pt.internUnion(.{ .ty = ty.toIntern(), .tag = tag_val.toIntern(), .val = val_val.toIntern(), - } }); + }); return Value.fromInterned(only); }, @@ -38849,7 +38690,7 @@ fn analyzeUnreachable(sema: *Sema, block: *Block, src: LazySrcLoc, safety_check: sema.branch_hint = .cold; } - try sema.safetyPanic(block, src, .unreach); + try sema.safetyPanic(block, src, .reached_unreachable); } else { _ = try block.addNoOp(.unreach); } @@ -39123,3 +38964,36 @@ const loadComptimePtr = @import("Sema/comptime_ptr_access.zig").loadComptimePtr; const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadResult; const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr; const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult; + +/// Convenience function that looks 2 levels deep into `std.builtin`. +fn getBuiltinInnerType( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + outer_name: []const u8, + inner_name: []const u8, +) !Type { + const outer_ty = try sema.pt.getBuiltinType(outer_name); + return getInnerType(sema, block, src, outer_ty, inner_name); +} + +fn getInnerType( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + outer_ty: Type, + inner_name: []const u8, +) !Type { + const pt = sema.pt; + const zcu = pt.zcu; + const ip = &zcu.intern_pool; + const gpa = sema.gpa; + const nav = try sema.namespaceLookup( + block, + src, + outer_ty.getNamespaceIndex(zcu), + try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls), + ) orelse return sema.fail(block, src, "std.builtin missing {s}", .{inner_name}); + try sema.ensureNavResolved(src, nav); + return Type.fromInterned(ip.getNav(nav).status.resolved.val); +} diff --git a/src/Sema/bitcast.zig b/src/Sema/bitcast.zig index d3adbe7eb82b..25955b113f5b 100644 --- a/src/Sema/bitcast.zig +++ b/src/Sema/bitcast.zig @@ -613,11 +613,11 @@ const PackValueBits = struct { pack.bit_offset = prev_bit_offset; break :backing; } - return Value.fromInterned(try pt.intern(.{ .un = .{ + return Value.fromInterned(try pt.internUnion(.{ .ty = ty.toIntern(), .tag = .none, .val = backing_val.toIntern(), - } })); + })); } const field_order = try pack.arena.alloc(u32, ty.unionTagTypeHypothetical(zcu).enumFieldCount(zcu)); @@ -658,21 +658,21 @@ const PackValueBits = struct { continue; } const tag_val = try pt.enumValueFieldIndex(ty.unionTagTypeHypothetical(zcu), field_idx); - return Value.fromInterned(try pt.intern(.{ .un = .{ + return Value.fromInterned(try pt.internUnion(.{ .ty = ty.toIntern(), .tag = tag_val.toIntern(), .val = field_val.toIntern(), - } })); + })); } // No field could represent the value. Just do whatever happens when we try to read // the backing type - either `undefined` or `error.ReinterpretDeclRef`. const backing_val = try pack.get(backing_ty); - return Value.fromInterned(try pt.intern(.{ .un = .{ + return Value.fromInterned(try pt.internUnion(.{ .ty = ty.toIntern(), .tag = .none, .val = backing_val.toIntern(), - } })); + })); }, else => return pack.primitive(ty), } diff --git a/src/Type.zig b/src/Type.zig index e4c7f7ab7ae6..19ddf6dfedf3 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -2677,11 +2677,11 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value { const only_field_ty = union_obj.field_types.get(ip)[0]; const val_val = (try Type.fromInterned(only_field_ty).onePossibleValue(pt)) orelse return null; - const only = try pt.intern(.{ .un = .{ + const only = try pt.internUnion(.{ .ty = ty.toIntern(), .tag = tag_val.toIntern(), .val = val_val.toIntern(), - } }); + }); return Value.fromInterned(only); }, .opaque_type => return null, diff --git a/src/Value.zig b/src/Value.zig index d6e533429a47..157f47bc7e00 100644 --- a/src/Value.zig +++ b/src/Value.zig @@ -713,11 +713,11 @@ pub fn readFromMemory( const union_size = ty.abiSize(zcu); const array_ty = try zcu.arrayType(.{ .len = union_size, .child = .u8_type }); const val = (try readFromMemory(array_ty, zcu, buffer, arena)).toIntern(); - return Value.fromInterned(try pt.intern(.{ .un = .{ + return Value.fromInterned(try pt.internUnion(.{ .ty = ty.toIntern(), .tag = .none, .val = val, - } })); + })); }, .@"packed" => { const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8; @@ -860,11 +860,11 @@ pub fn readFromPackedMemory( .@"packed" => { const backing_ty = try ty.unionBackingType(pt); const val = (try readFromPackedMemory(backing_ty, pt, buffer, bit_offset, arena)).toIntern(); - return Value.fromInterned(try pt.intern(.{ .un = .{ + return Value.fromInterned(try pt.internUnion(.{ .ty = ty.toIntern(), .tag = .none, .val = val, - } })); + })); }, }, .pointer => { @@ -4481,11 +4481,11 @@ pub fn resolveLazy( return if (resolved_tag == un.tag and resolved_val == un.val) val else - Value.fromInterned(try pt.intern(.{ .un = .{ + Value.fromInterned(try pt.internUnion(.{ .ty = un.ty, .tag = resolved_tag, .val = resolved_val, - } })); + })); }, else => return val, } diff --git a/src/Zcu.zig b/src/Zcu.zig index e71e7fae9d1f..f5f433ed9ccd 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -210,45 +210,15 @@ all_type_references: std.ArrayListUnmanaged(TypeReference) = .empty, /// Freelist of indices in `all_type_references`. free_type_references: std.ArrayListUnmanaged(u32) = .empty, -panic_messages: [PanicId.len]InternPool.Nav.Index.Optional = .{.none} ** PanicId.len, /// The panic function body. panic_func_index: InternPool.Index = .none, null_stack_trace: InternPool.Index = .none, +panic_cause_type: InternPool.Index = .none, generation: u32 = 0, pub const PerThread = @import("Zcu/PerThread.zig"); -pub const PanicId = enum { - unreach, - unwrap_null, - cast_to_null, - incorrect_alignment, - invalid_error_code, - cast_truncated_data, - negative_to_unsigned, - integer_overflow, - shl_overflow, - shr_overflow, - divide_by_zero, - exact_division_remainder, - inactive_union_field, - integer_part_out_of_bounds, - corrupt_switch, - shift_rhs_too_big, - invalid_enum_value, - sentinel_mismatch, - unwrap_error, - index_out_of_bounds, - start_index_greater_than_end, - for_len_mismatch, - memcpy_len_mismatch, - memcpy_alias, - noreturn_returned, - - pub const len = @typeInfo(PanicId).@"enum".fields.len; -}; - pub const GlobalErrorSet = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void); pub const CImportError = struct { @@ -2926,14 +2896,6 @@ pub const Feature = enum { /// When this feature is enabled, Sema will emit calls to `std.builtin.panic` /// for things like safety checks and unreachables. Otherwise traps will be emitted. panic_fn, - /// When this feature is enabled, Sema will emit calls to `std.builtin.panicUnwrapError`. - /// This error message requires more advanced formatting, hence it being seperate from `panic_fn`. - /// Otherwise traps will be emitted. - panic_unwrap_error, - /// When this feature is enabled, Sema will emit calls to the more complex panic functions - /// that use formatting to add detail to error messages. Similar to `panic_unwrap_error`. - /// Otherwise traps will be emitted. - safety_check_formatted, /// When this feature is enabled, Sema will insert tracer functions for gathering a stack /// trace for error returns. error_return_trace, diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index a11910302d6e..a0e90e60bd1e 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -2697,11 +2697,16 @@ pub fn reportRetryableFileError( gop.value_ptr.* = err_msg; } -///Shortcut for calling `intern_pool.get`. +/// Shortcut for calling `intern_pool.get`. pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index { return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key); } +/// Shortcut for calling `intern_pool.getUnion`. +pub fn internUnion(pt: Zcu.PerThread, un: InternPool.Key.Union) Allocator.Error!InternPool.Index { + return pt.zcu.intern_pool.getUnion(pt.zcu.gpa, pt.tid, un); +} + /// Essentially a shortcut for calling `intern_pool.getCoerced`. /// However, this function also allows coercing `extern`s. The `InternPool` function can't do /// this because it requires potentially pushing to the job queue. @@ -2949,11 +2954,12 @@ pub fn intValue_i64(pt: Zcu.PerThread, ty: Type, x: i64) Allocator.Error!Value { } pub fn unionValue(pt: Zcu.PerThread, union_ty: Type, tag: Value, val: Value) Allocator.Error!Value { - return Value.fromInterned(try pt.intern(.{ .un = .{ + const zcu = pt.zcu; + return Value.fromInterned(try zcu.intern_pool.getUnion(zcu.gpa, pt.tid, .{ .ty = union_ty.toIntern(), .tag = tag.toIntern(), .val = val.toIntern(), - } })); + })); } /// This function casts the float representation down to the representation of the type, potentially diff --git a/src/crash_report.zig b/src/crash_report.zig index c0a90d870572..fb681c8f089f 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -17,7 +17,7 @@ const Decl = Zcu.Decl; /// To use these crash report diagnostics, publish this panic in your main file /// and add `pub const enable_segfault_handler = false;` to your `std_options`. /// You will also need to call initialize() on startup, preferably as the very first operation in your program. -pub const panic = if (build_options.enable_debug_extensions) compilerPanic else std.builtin.default_panic; +pub const panic = if (build_options.enable_debug_extensions) compilerPanic else std.debug.defaultPanic; /// Install signal handlers to identify crashes and report diagnostics. pub fn initialize() void { @@ -152,12 +152,16 @@ fn writeFilePath(file: *Zcu.File, writer: anytype) !void { try writer.writeAll(file.sub_file_path); } -pub fn compilerPanic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, maybe_ret_addr: ?usize) noreturn { +pub fn compilerPanic( + cause: std.builtin.PanicCause, + error_return_trace: ?*std.builtin.StackTrace, + maybe_ret_addr: ?usize, +) noreturn { @branchHint(.cold); PanicSwitch.preDispatch(); 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); + PanicSwitch.dispatch(error_return_trace, stack_ctx, cause); } /// Attaches a global SIGSEGV handler @@ -354,17 +358,17 @@ const PanicSwitch = struct { pub fn dispatch( trace: ?*const std.builtin.StackTrace, stack_ctx: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { var panic_state: *volatile PanicState = &panic_state_raw; debug.assert(panic_state.awaiting_dispatch); panic_state.awaiting_dispatch = false; nosuspend switch (panic_state.recover_stage) { - .initialize => goTo(initPanic, .{ panic_state, trace, stack_ctx, msg }), - .report_stack => goTo(recoverReportStack, .{ panic_state, trace, stack_ctx, msg }), - .release_mutex => goTo(recoverReleaseMutex, .{ panic_state, trace, stack_ctx, msg }), - .release_ref_count => goTo(recoverReleaseRefCount, .{ panic_state, trace, stack_ctx, msg }), - .abort => goTo(recoverAbort, .{ panic_state, trace, stack_ctx, msg }), + .initialize => goTo(initPanic, .{ panic_state, trace, stack_ctx, panic_cause }), + .report_stack => goTo(recoverReportStack, .{ panic_state, trace, stack_ctx, panic_cause }), + .release_mutex => goTo(recoverReleaseMutex, .{ panic_state, trace, stack_ctx, panic_cause }), + .release_ref_count => goTo(recoverReleaseRefCount, .{ panic_state, trace, stack_ctx, panic_cause }), + .abort => goTo(recoverAbort, .{ panic_state, trace, stack_ctx, panic_cause }), .silent_abort => goTo(abort, .{}), }; } @@ -373,7 +377,7 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { // use a temporary so there's only one volatile store const new_state = PanicState{ @@ -398,6 +402,8 @@ const PanicSwitch = struct { const current_thread_id = std.Thread.getCurrentId(); stderr.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state}); } + var buffer: [1000]u8 = undefined; + const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; stderr.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state}); state.recover_stage = .report_stack; @@ -413,9 +419,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { - recover(state, trace, stack, msg); + recover(state, trace, stack, panic_cause); state.recover_stage = .release_mutex; const stderr = io.getStdErr().writer(); @@ -438,9 +444,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { - recover(state, trace, stack, msg); + recover(state, trace, stack, panic_cause); goTo(releaseMutex, .{state}); } @@ -456,9 +462,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { - recover(state, trace, stack, msg); + recover(state, trace, stack, panic_cause); goTo(releaseRefCount, .{state}); } @@ -484,9 +490,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) noreturn { - recover(state, trace, stack, msg); + recover(state, trace, stack, panic_cause); state.recover_stage = .silent_abort; const stderr = io.getStdErr().writer(); @@ -510,7 +516,7 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - msg: []const u8, + panic_cause: std.builtin.PanicCause, ) void { switch (state.recover_verbosity) { .message_and_stack => { @@ -519,7 +525,7 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked during a panic: ") catch {}; - stderr.writeAll(msg) catch {}; + stderr.writeAll(panic_cause) catch {}; stderr.writeAll("\nInner panic stack:\n") catch {}; if (trace) |t| { debug.dumpStackTrace(t.*); @@ -533,7 +539,7 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {}; - stderr.writeAll(msg) catch {}; + stderr.writeAll(panic_cause) catch {}; stderr.writeAll("\n") catch {}; // If we succeed, restore all the way to dumping the stack. diff --git a/src/main.zig b/src/main.zig index 3e7813019ea6..b08acf568c62 100644 --- a/src/main.zig +++ b/src/main.zig @@ -826,7 +826,6 @@ fn buildOutputType( var version: std.SemanticVersion = .{ .major = 0, .minor = 0, .patch = 0 }; var have_version = false; var compatibility_version: ?std.SemanticVersion = null; - var formatted_panics: ?bool = null; var function_sections = false; var data_sections = false; var no_builtin = false; @@ -1537,9 +1536,11 @@ fn buildOutputType( } else if (mem.eql(u8, arg, "-gdwarf64")) { create_module.opts.debug_format = .{ .dwarf = .@"64" }; } else if (mem.eql(u8, arg, "-fformatted-panics")) { - formatted_panics = true; + // Remove this after 0.15.0 is tagged. + warn("-fformatted-panics is deprecated and does nothing", .{}); } else if (mem.eql(u8, arg, "-fno-formatted-panics")) { - formatted_panics = false; + // Remove this after 0.15.0 is tagged. + warn("-fno-formatted-panics is deprecated and does nothing", .{}); } else if (mem.eql(u8, arg, "-fsingle-threaded")) { mod_opts.single_threaded = true; } else if (mem.eql(u8, arg, "-fno-single-threaded")) { @@ -3405,7 +3406,6 @@ fn buildOutputType( .force_undefined_symbols = force_undefined_symbols, .stack_size = stack_size, .image_base = image_base, - .formatted_panics = formatted_panics, .function_sections = function_sections, .data_sections = data_sections, .no_builtin = no_builtin, diff --git a/src/mutable_value.zig b/src/mutable_value.zig index 49826c2fb2ad..9e63494d12ff 100644 --- a/src/mutable_value.zig +++ b/src/mutable_value.zig @@ -88,11 +88,11 @@ pub const MutableValue = union(enum) { .ptr = (try s.ptr.intern(pt, arena)).toIntern(), .len = (try s.len.intern(pt, arena)).toIntern(), } }), - .un => |u| try pt.intern(.{ .un = .{ + .un => |u| try pt.internUnion(.{ .ty = u.ty, .tag = u.tag, .val = (try u.payload.intern(pt, arena)).toIntern(), - } }), + }), }); } diff --git a/src/target.zig b/src/target.zig index d85981ec8403..6348543f9486 100644 --- a/src/target.zig +++ b/src/target.zig @@ -586,14 +586,6 @@ pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, compt => true, else => false, }, - .panic_unwrap_error => switch (backend) { - .stage2_c, .stage2_llvm => true, - else => false, - }, - .safety_check_formatted => switch (backend) { - .stage2_c, .stage2_llvm => true, - else => false, - }, .error_return_trace => switch (backend) { .stage2_llvm => true, else => false, diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig index 492f7958b18b..818d7e31a562 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,7 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn { _ = stack_trace; + _ = ret_addr; if (std.mem.eql(u8, message, "reached unreachable code")) { std.process.exit(0); } From 9ccf8d3332dd9c1e4d967e3b8af2b98128d360ca Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 13:22:47 -0700 Subject: [PATCH 03/21] fixes for this branch I had to bring back some of the old API so that I could compile the new compiler with an old compiler. --- lib/std/builtin.zig | 77 +++++++++++++++++++++++++++++++++++- lib/std/debug.zig | 18 ++------- src/Sema.zig | 28 ++++++++----- src/codegen/llvm.zig | 93 +++++++++++++++++++++++--------------------- src/crash_report.zig | 11 ++++-- 5 files changed, 152 insertions(+), 75 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 8530a64fedab..2718296a1110 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -761,18 +761,91 @@ pub const TestFn = struct { func: *const fn () anyerror!void, }; +const old_version = std.SemanticVersion.parse("0.14.0-dev.1659+4ceefca14") catch unreachable; +const is_old = @import("builtin").zig_version.order(old_version) != .gt; + /// 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 (PanicCause, ?*StackTrace, ?usize) noreturn; +pub const PanicFn = if (is_old) + fn ([]const u8, ?*StackTrace, ?usize) noreturn +else + fn (PanicCause, ?*StackTrace, ?usize) noreturn; /// The entry point for auto-generated calls by the compiler. -pub const panic: PanicFn = if (@hasDecl(root, "panic")) +pub const panic: PanicFn = if (is_old) + defaultPanicOld +else if (@hasDecl(root, "panic")) root.panic else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) root.os.panic else std.debug.defaultPanic; +pub fn defaultPanicOld( + msg: []const u8, + trace: ?*const std.builtin.StackTrace, + first_trace_addr: ?usize, +) noreturn { + @branchHint(.cold); + std.debug.print("old panic: {s}\n", .{msg}); + _ = trace; + _ = first_trace_addr; + @trap(); +} + +pub fn panicSentinelMismatch(expected: anytype, actual: @TypeOf(expected)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ expected, actual }); +} + +pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn { + @branchHint(.cold); + std.debug.panicExtra(st, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)}); +} + +pub fn panicOutOfBounds(index: usize, len: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len }); +} + +pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end }); +} + +pub fn panicInactiveUnionField(active: anytype, wanted: @TypeOf(active)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ @tagName(wanted), @tagName(active) }); +} + +pub const panic_messages = struct { + pub const unreach = "reached unreachable code"; + pub const unwrap_null = "attempt to use null value"; + pub const cast_to_null = "cast causes pointer to be null"; + pub const incorrect_alignment = "incorrect alignment"; + pub const invalid_error_code = "invalid error code"; + pub const cast_truncated_data = "integer cast truncated bits"; + pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer"; + pub const integer_overflow = "integer overflow"; + pub const shl_overflow = "left shift overflowed bits"; + pub const shr_overflow = "right shift overflowed bits"; + pub const divide_by_zero = "division by zero"; + pub const exact_division_remainder = "exact division produced remainder"; + pub const inactive_union_field = "access of inactive union field"; + pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds"; + pub const corrupt_switch = "switch on corrupt value"; + pub const shift_rhs_too_big = "shift amount is greater than the type size"; + pub const invalid_enum_value = "invalid enum value"; + pub const sentinel_mismatch = "sentinel mismatch"; + pub const unwrap_error = "attempt to unwrap error"; + pub const index_out_of_bounds = "index out of bounds"; + pub const start_index_greater_than_end = "start index is larger than end index"; + pub const for_len_mismatch = "for loop over objects with non-equal lengths"; + pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths"; + pub const memcpy_alias = "@memcpy arguments alias"; + pub const noreturn_returned = "'noreturn' function returned"; +}; + /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PanicCause = union(enum) { diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 8e5498b3f5ba..d6312598d1a8 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -437,7 +437,7 @@ pub fn panicExtra( break :blk &buf; }, }; - std.builtin.panic(msg, trace, ret_addr); + std.builtin.panic(.{ .explicit_call = msg }, trace, ret_addr); } /// Non-zero whenever the program triggered a panic. @@ -487,18 +487,6 @@ pub fn defaultPanic( .freestanding => { @trap(); }, - .wasi => { - // TODO: before merging my branch, unify this logic with the main panic logic - var buffer: [1000]u8 = undefined; - var i: usize = 0; - i += fmtPanicCause(buffer[i..], cause); - buffer[i] = '\n'; - i += 1; - const msg = buffer[0..i]; - lockStdErr(); - io.getStdErr().writeAll(msg) catch {}; - @trap(); - }, .uefi => { const uefi = std.os.uefi; @@ -571,7 +559,7 @@ pub fn defaultPanic( i += fmtInt10(buffer[i..], std.Thread.getCurrentId()); i += fmtBuf(buffer[i..], " panic: "); } - i += fmtPanicCause(&buffer, cause); + i += fmtPanicCause(buffer[i..], cause); buffer[i] = '\n'; i += 1; const msg = buffer[0..i]; @@ -672,7 +660,7 @@ fn fmtInt10(out_buf: []u8, integer_value: usize) usize { while (true) { i -= 1; - tmp_buf[i] = '0' + (a % 10); + tmp_buf[i] = '0' + @as(u8, @intCast(a % 10)); a /= 10; if (a == 0) break; } diff --git a/src/Sema.zig b/src/Sema.zig index a2d883a04067..fd4c8cfa4f52 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -2566,7 +2566,7 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Zcu.ErrorMsg std.debug.print("compile error during Sema:\n", .{}); var error_bundle = wip_errors.toOwnedBundle("") catch @panic("out of memory"); error_bundle.renderToStdErr(.{ .ttyconf = .no_color }); - crash_report.compilerPanic("unexpected compile error occurred", null, null); + crash_report.compilerPanic(.{ .explicit_call = "unexpected compile error occurred" }, null, null); } if (block) |start_block| { @@ -7334,17 +7334,21 @@ fn callPanic( call_operation: CallOperation, ) !void { const pt = sema.pt; - if (!pt.zcu.backendSupportsFeature(.panic_fn)) { + const zcu = pt.zcu; + if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try block.addNoOp(.trap); return; } const panic_cause_ty = try pt.getBuiltinType("PanicCause"); - const panic_cause = try block.addUnionInit(panic_cause_ty, @intFromEnum(tag), payload); + const panic_cause = if (payload == .void_value) + try initUnionFromEnumTag(pt, panic_cause_ty, panic_cause_ty.unionTagType(zcu).?, @intFromEnum(tag)) + else + try block.addUnionInit(panic_cause_ty, @intFromEnum(tag), payload); const panic_fn = try pt.getBuiltin("panic"); const err_return_trace = try sema.getErrorReturnTrace(block); const opt_usize_ty = try pt.optionalType(.usize_type); const null_usize = try pt.nullValue(opt_usize_ty); - const args: [3]Air.Inst.Ref = .{ panic_cause, err_return_trace, Air.internedToRef(null_usize) }; + const args: [3]Air.Inst.Ref = .{ panic_cause, err_return_trace, Air.internedToRef(null_usize.toIntern()) }; try sema.callBuiltin(block, call_src, panic_fn, .auto, &args, call_operation); } @@ -18326,11 +18330,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .undefined, .null, .enum_literal, - => |type_info_tag| return Air.internedToRef((try pt.internUnion(.{ - .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(type_info_tag))).toIntern(), - .val = .void_value, - }))), + => |type_info_tag| return initUnionFromEnumTag(pt, type_info_ty, type_info_tag_ty, @intFromEnum(type_info_tag)), .@"fn" => { const fn_info_ty = try getInnerType(sema, block, src, type_info_ty, "Fn"); const param_info_ty = try getInnerType(sema, block, src, fn_info_ty, "Param"); @@ -28009,7 +28009,7 @@ fn addSafetyCheckSentinelMismatch( assert(std.mem.eql(u8, fields[1].name, "found")); assert(fields.len == 2); } - const panic_cause_payload = &fail_block.addAggregateInit(mm_ty, &.{ expected_sentinel, actual_sentinel }); + const panic_cause_payload = try fail_block.addAggregateInit(mm_ty, &.{ expected_sentinel, actual_sentinel }); try callPanic(sema, &fail_block, src, .sentinel_mismatch_usize, panic_cause_payload, .@"safety check"); } else { try callPanic(sema, &fail_block, src, .sentinel_mismatch_other, .void_value, .@"safety check"); @@ -38997,3 +38997,11 @@ fn getInnerType( try sema.ensureNavResolved(src, nav); return Type.fromInterned(ip.getNav(nav).status.resolved.val); } + +fn initUnionFromEnumTag(pt: Zcu.PerThread, union_ty: Type, union_tag_ty: Type, field_index: u32) !Air.Inst.Ref { + return Air.internedToRef((try pt.internUnion(.{ + .ty = union_ty.toIntern(), + .tag = (try pt.enumValueFieldIndex(union_tag_ty, field_index)).toIntern(), + .val = .void_value, + }))); +} diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 816975955a15..78ac35e9eb13 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -3848,13 +3848,13 @@ pub const Object = struct { .undef => unreachable, // handled above .simple_value => |simple_value| switch (simple_value) { - .undefined, - .void, - .null, - .empty_struct, - .@"unreachable", - .generic_poison, - => unreachable, // non-runtime values + .undefined => unreachable, // non-runtime value + .void => unreachable, // non-runtime value + .null => unreachable, // non-runtime value + .empty_struct => unreachable, // non-runtime value + .@"unreachable" => unreachable, // non-runtime value + .generic_poison => unreachable, // non-runtime value + .false => .false, .true => .true, }, @@ -5675,43 +5675,48 @@ pub const FuncGen = struct { } } - fn buildSimplePanic(fg: *FuncGen, panic_id: Zcu.PanicId) !void { - const o = fg.ng.object; - const zcu = o.pt.zcu; - const ip = &zcu.intern_pool; - const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?; - const msg_nav = ip.getNav(msg_nav_index); - const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu); - const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val); - const null_opt_addr_global = try fg.resolveNullOptUsize(); - const target = zcu.getTarget(); - const llvm_usize = try o.lowerType(Type.usize); - // example: - // call fastcc void @test2.panic( - // ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr - // i64 16, ; msg.len - // ptr null, ; stack trace - // ptr @2, ; addr (null ?usize) - // ) - const panic_func = zcu.funcInfo(zcu.panic_func_index); - const panic_nav = ip.getNav(panic_func.owner_nav); - const fn_info = zcu.typeToFunc(Type.fromInterned(panic_nav.typeOf(ip))).?; - const panic_global = try o.resolveLlvmFunction(panic_func.owner_nav); - _ = try fg.wip.callIntrinsicAssumeCold(); - _ = try fg.wip.call( - .normal, - toLlvmCallConv(fn_info.cc, target), - .none, - panic_global.typeOf(&o.builder), - panic_global.toValue(&o.builder), - &.{ - msg_ptr.toValue(), - try o.builder.intValue(llvm_usize, msg_len), - try o.builder.nullValue(.ptr), - null_opt_addr_global.toValue(), - }, - "", - ); + const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?; + + fn buildSimplePanic(fg: *FuncGen, panic_cause_tag: PanicCauseTag) !void { + // TODO update this before merging the branch + _ = panic_cause_tag; + //const o = fg.ng.object; + //const zcu = o.pt.zcu; + //const ip = &zcu.intern_pool; + //const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?; + //const msg_nav = ip.getNav(msg_nav_index); + //const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu); + //const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val); + //const null_opt_addr_global = try fg.resolveNullOptUsize(); + //const target = zcu.getTarget(); + //const llvm_usize = try o.lowerType(Type.usize); + //// example: + //// call fastcc void @test2.panic( + //// ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr + //// i64 16, ; msg.len + //// ptr null, ; stack trace + //// ptr @2, ; addr (null ?usize) + //// ) + //const panic_func = zcu.funcInfo(zcu.panic_func_index); + //const panic_nav = ip.getNav(panic_func.owner_nav); + //const fn_info = zcu.typeToFunc(Type.fromInterned(panic_nav.typeOf(ip))).?; + //const panic_global = try o.resolveLlvmFunction(panic_func.owner_nav); + //_ = try fg.wip.callIntrinsicAssumeCold(); + //_ = try fg.wip.call( + // .normal, + // toLlvmCallConv(fn_info.cc, target), + // .none, + // panic_global.typeOf(&o.builder), + // panic_global.toValue(&o.builder), + // &.{ + // msg_ptr.toValue(), + // try o.builder.intValue(llvm_usize, msg_len), + // try o.builder.nullValue(.ptr), + // null_opt_addr_global.toValue(), + // }, + // "", + //); + _ = try fg.wip.callIntrinsic(.normal, .none, .trap, &.{}, &.{}, ""); _ = try fg.wip.@"unreachable"(); } diff --git a/src/crash_report.zig b/src/crash_report.zig index fb681c8f089f..e7a18d7f60e3 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -212,7 +212,7 @@ fn handleSegfaultPosix(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopa else => .not_supported, }; - PanicSwitch.dispatch(null, stack_ctx, error_msg); + PanicSwitch.dispatch(null, stack_ctx, .{ .explicit_call = error_msg }); } const WindowsSegfaultMessage = union(enum) { @@ -338,7 +338,7 @@ const PanicSwitch = struct { // it's happening and print a message. var panic_state: *volatile PanicState = &panic_state_raw; if (panic_state.awaiting_dispatch) { - dispatch(null, .{ .current = .{ .ret_addr = null } }, "Panic while preparing callstack"); + dispatch(null, .{ .current = .{ .ret_addr = null } }, .{ .explicit_call = "Panic while preparing callstack" }); } panic_state.awaiting_dispatch = true; } @@ -518,6 +518,7 @@ const PanicSwitch = struct { stack: StackContext, panic_cause: std.builtin.PanicCause, ) void { + var buffer: [1000]u8 = undefined; switch (state.recover_verbosity) { .message_and_stack => { // lower the verbosity, and restore it at the end if we don't panic. @@ -525,7 +526,8 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked during a panic: ") catch {}; - stderr.writeAll(panic_cause) catch {}; + const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; + stderr.writeAll(msg) catch {}; stderr.writeAll("\nInner panic stack:\n") catch {}; if (trace) |t| { debug.dumpStackTrace(t.*); @@ -539,7 +541,8 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {}; - stderr.writeAll(panic_cause) catch {}; + const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; + stderr.writeAll(msg) catch {}; stderr.writeAll("\n") catch {}; // If we succeed, restore all the way to dumping the stack. From 76f0b6e7d8dfa527f8776a4ffe61400fd84d871a Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 13:24:47 -0700 Subject: [PATCH 04/21] delete the old panic stuff again now that we have a zig1.wasm update it's not needed --- lib/std/builtin.zig | 77 ++------------------------------------------- 1 file changed, 2 insertions(+), 75 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 2718296a1110..8530a64fedab 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -761,91 +761,18 @@ pub const TestFn = struct { func: *const fn () anyerror!void, }; -const old_version = std.SemanticVersion.parse("0.14.0-dev.1659+4ceefca14") catch unreachable; -const is_old = @import("builtin").zig_version.order(old_version) != .gt; - /// 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 = if (is_old) - fn ([]const u8, ?*StackTrace, ?usize) noreturn -else - fn (PanicCause, ?*StackTrace, ?usize) noreturn; +pub const PanicFn = fn (PanicCause, ?*StackTrace, ?usize) noreturn; /// The entry point for auto-generated calls by the compiler. -pub const panic: PanicFn = if (is_old) - defaultPanicOld -else if (@hasDecl(root, "panic")) +pub const panic: PanicFn = if (@hasDecl(root, "panic")) root.panic else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) root.os.panic else std.debug.defaultPanic; -pub fn defaultPanicOld( - msg: []const u8, - trace: ?*const std.builtin.StackTrace, - first_trace_addr: ?usize, -) noreturn { - @branchHint(.cold); - std.debug.print("old panic: {s}\n", .{msg}); - _ = trace; - _ = first_trace_addr; - @trap(); -} - -pub fn panicSentinelMismatch(expected: anytype, actual: @TypeOf(expected)) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ expected, actual }); -} - -pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn { - @branchHint(.cold); - std.debug.panicExtra(st, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)}); -} - -pub fn panicOutOfBounds(index: usize, len: usize) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len }); -} - -pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end }); -} - -pub fn panicInactiveUnionField(active: anytype, wanted: @TypeOf(active)) noreturn { - @branchHint(.cold); - std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ @tagName(wanted), @tagName(active) }); -} - -pub const panic_messages = struct { - pub const unreach = "reached unreachable code"; - pub const unwrap_null = "attempt to use null value"; - pub const cast_to_null = "cast causes pointer to be null"; - pub const incorrect_alignment = "incorrect alignment"; - pub const invalid_error_code = "invalid error code"; - pub const cast_truncated_data = "integer cast truncated bits"; - pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer"; - pub const integer_overflow = "integer overflow"; - pub const shl_overflow = "left shift overflowed bits"; - pub const shr_overflow = "right shift overflowed bits"; - pub const divide_by_zero = "division by zero"; - pub const exact_division_remainder = "exact division produced remainder"; - pub const inactive_union_field = "access of inactive union field"; - pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds"; - pub const corrupt_switch = "switch on corrupt value"; - pub const shift_rhs_too_big = "shift amount is greater than the type size"; - pub const invalid_enum_value = "invalid enum value"; - pub const sentinel_mismatch = "sentinel mismatch"; - pub const unwrap_error = "attempt to unwrap error"; - pub const index_out_of_bounds = "index out of bounds"; - pub const start_index_greater_than_end = "start index is larger than end index"; - pub const for_len_mismatch = "for loop over objects with non-equal lengths"; - pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths"; - pub const memcpy_alias = "@memcpy arguments alias"; - pub const noreturn_returned = "'noreturn' function returned"; -}; - /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PanicCause = union(enum) { From f2c8940aa6b1bd6ca20730e13b8148af002e1b91 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 16:20:19 -0700 Subject: [PATCH 05/21] reintroduce the std.builtin safety panic helpers motivated by performance --- lib/std/builtin.zig | 73 +++++++++++++++++++-- lib/std/debug.zig | 19 +++++- src/Sema.zig | 151 ++++++++++++-------------------------------- 3 files changed, 126 insertions(+), 117 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 8530a64fedab..4edcebad53ad 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -803,6 +803,7 @@ pub const PanicCause = union(enum) { memcpy_alias, noreturn_returned, explicit_call: []const u8, + sentinel_mismatch_isize: SentinelMismatchIsize, pub const IndexOutOfBounds = struct { index: usize, @@ -819,22 +820,82 @@ pub const PanicCause = union(enum) { found: usize, }; + pub const SentinelMismatchIsize = struct { + expected: isize, + found: isize, + }; + pub const InactiveUnionField = struct { active: []const u8, accessed: []const u8, }; }; -pub noinline fn returnError(st: *StackTrace) void { +pub fn panicSentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { @branchHint(.cold); - @setRuntimeSafety(false); - addErrRetTraceAddr(st, @returnAddress()); + switch (@typeInfo(@TypeOf(expected))) { + .int => |int| switch (int.signedness) { + .unsigned => if (int.bits <= @bitSizeOf(usize)) panic(.{ .sentinel_mismatch_usize = .{ + .expected = expected, + .found = found, + } }, null, @returnAddress()), + .signed => if (int.bits <= @bitSizeOf(isize)) panic(.{ .sentinel_mismatch_isize = .{ + .expected = expected, + .found = found, + } }, null, @returnAddress()), + }, + .@"enum" => |info| switch (@typeInfo(info.tag_type)) { + .int => |int| switch (int.signedness) { + .unsigned => if (int.bits <= @bitSizeOf(usize)) panic(.{ .sentinel_mismatch_usize = .{ + .expected = @intFromEnum(expected), + .found = @intFromEnum(found), + } }, null, @returnAddress()), + .signed => if (int.bits <= @bitSizeOf(isize)) panic(.{ .sentinel_mismatch_isize = .{ + .expected = @intFromEnum(expected), + .found = @intFromEnum(found), + } }, null, @returnAddress()), + }, + else => comptime unreachable, + }, + else => {}, + } + panic(.sentinel_mismatch_other, null, @returnAddress()); } -pub inline fn addErrRetTraceAddr(st: *StackTrace, addr: usize) void { - if (st.index < st.instruction_addresses.len) - st.instruction_addresses[st.index] = addr; +pub fn panicUnwrapError(ert: ?*StackTrace, err: anyerror) noreturn { + @branchHint(.cold); + panic(.{ .unwrap_error = err }, ert, @returnAddress()); +} + +pub fn panicOutOfBounds(index: usize, len: usize) noreturn { + @branchHint(.cold); + panic(.{ .index_out_of_bounds = .{ + .index = index, + .len = len, + } }, null, @returnAddress()); +} + +pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { + @branchHint(.cold); + panic(.{ .start_index_greater_than_end = .{ + .start = start, + .end = end, + } }, null, @returnAddress()); +} +pub fn panicInactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { + @branchHint(.cold); + panic(.{ .inactive_union_field = .{ + .active = @tagName(active), + .accessed = @tagName(accessed), + } }, null, @returnAddress()); +} + +pub noinline fn returnError(st: *StackTrace) void { + @branchHint(.unlikely); + @setRuntimeSafety(false); + if (st.index < st.instruction_addresses.len) + st.instruction_addresses[st.index] = @returnAddress(); st.index += 1; } diff --git a/lib/std/debug.zig b/lib/std/debug.zig index d6312598d1a8..7bfc6b321e2b 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -453,7 +453,7 @@ threadlocal var panic_stage: usize = 0; // This function avoids a dependency on formatted printing. pub fn defaultPanic( cause: std.builtin.PanicCause, - trace: ?*const std.builtin.StackTrace, + error_return_trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, ) noreturn { @branchHint(.cold); @@ -568,7 +568,7 @@ pub fn defaultPanic( defer unlockStdErr(); io.getStdErr().writeAll(msg) catch posix.abort(); - if (trace) |t| dumpStackTrace(t.*); + if (error_return_trace) |t| dumpStackTrace(t.*); dumpCurrentStackTrace(first_trace_addr orelse @returnAddress()); } @@ -621,6 +621,12 @@ pub fn fmtPanicCause(buffer: []u8, cause: std.builtin.PanicCause) usize { i += fmtBuf(buffer[i..], ", found "); i += fmtInt10(buffer[i..], mm.found); }, + .sentinel_mismatch_isize => |mm| { + i += fmtBuf(buffer[i..], "sentinel mismatch: expected "); + i += fmtInt10s(buffer[i..], mm.expected); + i += fmtBuf(buffer[i..], ", found "); + i += fmtInt10s(buffer[i..], mm.found); + }, .sentinel_mismatch_other => i += fmtBuf(buffer[i..], "sentinel mismatch"), .unwrap_error => |err| { i += fmtBuf(buffer[i..], "attempt to unwrap error: "); @@ -653,6 +659,15 @@ fn fmtBuf(out_buf: []u8, s: []const u8) usize { return s.len; } +fn fmtInt10s(out_buf: []u8, integer_value: isize) usize { + if (integer_value < 0) { + out_buf[0] = '-'; + return 1 + fmtInt10(out_buf[1..], @abs(integer_value)); + } else { + return fmtInt10(out_buf, @abs(integer_value)); + } +} + fn fmtInt10(out_buf: []u8, integer_value: usize) usize { var tmp_buf: [50]u8 = undefined; var i: usize = tmp_buf.len; diff --git a/src/Sema.zig b/src/Sema.zig index fd4c8cfa4f52..1b98ba3fe879 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -14249,7 +14249,7 @@ fn maybeErrorUnwrap( .as_node => try sema.zirAsNode(block, inst), .field_val => try sema.zirFieldVal(block, inst), .@"unreachable" => { - try callPanic(sema, block, operand_src, .unwrap_error, operand, .@"safety check"); + try safetyPanicUnwrapError(sema, block, operand_src, operand); return true; }, .panic => { @@ -27827,11 +27827,24 @@ fn addSafetyCheckUnwrapError( defer fail_block.instructions.deinit(gpa); const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); - try callPanic(sema, &fail_block, src, .unwrap_error, err, .@"safety check"); + try safetyPanicUnwrapError(sema, &fail_block, src, err); try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } +fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air.Inst.Ref) !void { + const pt = sema.pt; + const zcu = pt.zcu; + if (!zcu.backendSupportsFeature(.panic_fn)) { + _ = try block.addNoOp(.trap); + } else { + const panic_fn = try pt.getBuiltin("panicUnwrapError"); + const err_return_trace = try sema.getErrorReturnTrace(block); + const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; + try sema.callBuiltin(block, src, panic_fn, .auto, &args, .@"safety check"); + } +} + fn addSafetyCheckIndexOob( sema: *Sema, parent_block: *Block, @@ -27841,68 +27854,8 @@ fn addSafetyCheckIndexOob( cmp_op: Air.Inst.Tag, ) !void { assert(!parent_block.is_comptime); - const gpa = sema.gpa; const ok = try parent_block.addBinOp(cmp_op, index, len); - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - .src_base_inst = parent_block.src_base_inst, - .type_name_ctx = parent_block.type_name_ctx, - }; - - defer fail_block.instructions.deinit(gpa); - - const oob_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "IndexOutOfBounds"); - comptime { - const fields = @typeInfo(std.builtin.PanicCause.IndexOutOfBounds).@"struct".fields; - assert(std.mem.eql(u8, fields[0].name, "index")); - assert(std.mem.eql(u8, fields[1].name, "len")); - assert(fields.len == 2); - } - const panic_cause_payload = try fail_block.addAggregateInit(oob_ty, &.{ index, len }); - try callPanic(sema, &fail_block, src, .index_out_of_bounds, panic_cause_payload, .@"safety check"); - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); -} - -fn addSafetyCheckStartGreaterThanEnd( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - start: Air.Inst.Ref, - end: Air.Inst.Ref, -) !void { - assert(!parent_block.is_comptime); - const gpa = sema.gpa; - const ok = try parent_block.addBinOp(.cmp_lte, start, end); - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - .src_base_inst = parent_block.src_base_inst, - .type_name_ctx = parent_block.type_name_ctx, - }; - - defer fail_block.instructions.deinit(gpa); - - const oob_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "StartIndexGreaterThanEnd"); - comptime { - const fields = @typeInfo(std.builtin.PanicCause.StartIndexGreaterThanEnd).@"struct".fields; - assert(std.mem.eql(u8, fields[0].name, "start")); - assert(std.mem.eql(u8, fields[1].name, "end")); - assert(fields.len == 2); - } - const panic_cause_payload = try fail_block.addAggregateInit(oob_ty, &.{ start, end }); - try callPanic(sema, &fail_block, src, .start_index_greater_than_end, panic_cause_payload, .@"safety check"); - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); + return addSafetyCheckCall(sema, parent_block, src, ok, "panicOutOfBounds", &.{ index, len }); } fn addSafetyCheckInactiveUnionField( @@ -27913,36 +27866,8 @@ fn addSafetyCheckInactiveUnionField( wanted_tag: Air.Inst.Ref, ) !void { assert(!parent_block.is_comptime); - const gpa = sema.gpa; const ok = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag); - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - .src_base_inst = parent_block.src_base_inst, - .type_name_ctx = parent_block.type_name_ctx, - }; - - defer fail_block.instructions.deinit(gpa); - - const payload_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "InactiveUnionField"); - comptime { - const fields = @typeInfo(std.builtin.PanicCause.InactiveUnionField).@"struct".fields; - assert(std.mem.eql(u8, fields[0].name, "active")); - assert(std.mem.eql(u8, fields[1].name, "accessed")); - assert(fields.len == 2); - } - // TODO: before merging the branch, check how many safety checks end up being emitted - // for union field accesses and avoid extraneous ones. - const active_str = try analyzeTagName(sema, &fail_block, src, src, active_tag); - const accessed_str = try analyzeTagName(sema, &fail_block, src, src, wanted_tag); - const panic_cause_payload = try fail_block.addAggregateInit(payload_ty, &.{ active_str, accessed_str }); - try callPanic(sema, &fail_block, src, .inactive_union_field, panic_cause_payload, .@"safety check"); - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); + return addSafetyCheckCall(sema, parent_block, src, ok, "panicInactiveUnionField", &.{ active_tag, wanted_tag }); } fn addSafetyCheckSentinelMismatch( @@ -27955,7 +27880,6 @@ fn addSafetyCheckSentinelMismatch( sentinel_index: Air.Inst.Ref, ) !void { assert(!parent_block.is_comptime); - const gpa = sema.gpa; const pt = sema.pt; const zcu = pt.zcu; const expected_sentinel_val = maybe_sentinel orelse return; @@ -27984,6 +27908,24 @@ fn addSafetyCheckSentinelMismatch( break :ok try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel); }; + return addSafetyCheckCall(sema, parent_block, src, ok, "panicSentinelMismatch", &.{ + expected_sentinel, actual_sentinel, + }); +} + +fn addSafetyCheckCall( + sema: *Sema, + parent_block: *Block, + src: LazySrcLoc, + ok: Air.Inst.Ref, + func_name: []const u8, + args: []const Air.Inst.Ref, +) !void { + assert(!parent_block.is_comptime); + const gpa = sema.gpa; + const pt = sema.pt; + const zcu = pt.zcu; + var fail_block: Block = .{ .parent = parent_block, .sema = sema, @@ -27997,23 +27939,13 @@ fn addSafetyCheckSentinelMismatch( defer fail_block.instructions.deinit(gpa); - // A different PanicCause tag must be used depending on what payload type it can be fit into. - // If it cannot fit into any, the "other" tag can be used, which does not try to carry the - // sentinel value data. - - if (sentinel_ty.isUnsignedInt(zcu) and sentinel_ty.intInfo(zcu).bits <= Type.usize.intInfo(zcu).bits) { - const mm_ty = try getBuiltinInnerType(sema, &fail_block, src, "PanicCause", "SentinelMismatchUsize"); - comptime { - const fields = @typeInfo(std.builtin.PanicCause.SentinelMismatchUsize).@"struct".fields; - assert(std.mem.eql(u8, fields[0].name, "expected")); - assert(std.mem.eql(u8, fields[1].name, "found")); - assert(fields.len == 2); - } - const panic_cause_payload = try fail_block.addAggregateInit(mm_ty, &.{ expected_sentinel, actual_sentinel }); - try callPanic(sema, &fail_block, src, .sentinel_mismatch_usize, panic_cause_payload, .@"safety check"); + if (!zcu.backendSupportsFeature(.panic_fn)) { + _ = try fail_block.addNoOp(.trap); } else { - try callPanic(sema, &fail_block, src, .sentinel_mismatch_other, .void_value, .@"safety check"); + const panic_fn = try pt.getBuiltin(func_name); + try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); } + try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } @@ -33512,7 +33444,8 @@ fn analyzeSlice( // requirement: start <= end assert(!block.is_comptime); try sema.requireRuntimeBlock(block, src, runtime_src.?); - try sema.addSafetyCheckStartGreaterThanEnd(block, src, start, end); + const ok = try block.addBinOp(.cmp_lte, start, end); + try sema.addSafetyCheckCall(block, src, ok, "panicStartGreaterThanEnd", &.{ start, end }); } const new_len = if (by_length) try sema.coerce(block, Type.usize, uncasted_end_opt, end_src) From b66cc5af41aa0cc90996a75468a84ca83b46c1fd Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 18:23:45 -0700 Subject: [PATCH 06/21] reimplement integer overflow safety panic function calls in the llvm backend. --- src/Sema.zig | 43 +++++++++++++------------ src/Zcu.zig | 2 ++ src/Zcu/PerThread.zig | 19 +++++++++++ src/codegen/llvm.zig | 73 +++++++++++++++++++------------------------ 4 files changed, 74 insertions(+), 63 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 1b98ba3fe879..3d4844015c08 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -5703,27 +5703,7 @@ fn addStrLit(sema: *Sema, string: InternPool.String, len: u64) CompileError!Air. } fn uavRef(sema: *Sema, val: InternPool.Index) CompileError!Air.Inst.Ref { - return Air.internedToRef(try sema.refValue(val)); -} - -fn refValue(sema: *Sema, val: InternPool.Index) CompileError!InternPool.Index { - const pt = sema.pt; - const ptr_ty = (try pt.ptrTypeSema(.{ - .child = pt.zcu.intern_pool.typeOf(val), - .flags = .{ - .alignment = .none, - .is_const = true, - .address_space = .generic, - }, - })).toIntern(); - return pt.intern(.{ .ptr = .{ - .ty = ptr_ty, - .base_addr = .{ .uav = .{ - .val = val, - .orig_ty = ptr_ty, - } }, - .byte_offset = 0, - } }); + return Air.internedToRef(try sema.pt.refValue(val)); } fn zirInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { @@ -17402,6 +17382,7 @@ fn analyzeArithmetic( if (block.wantSafety() and want_safety and scalar_tag == .int) { if (zcu.backendSupportsFeature(.safety_checked_instructions)) { + if (air_tag != air_tag_safe) try sema.preparePanicIntegerOverflow(block, src); return block.addBinOp(air_tag_safe, casted_lhs, casted_rhs); } else { const maybe_op_ov: ?Air.Inst.Tag = switch (air_tag) { @@ -27706,6 +27687,24 @@ fn preparePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { const panic_cause_ty = try pt.getBuiltinType("PanicCause"); try panic_cause_ty.resolveFields(pt); zcu.panic_cause_type = panic_cause_ty.toIntern(); + zcu.panic_cause_tag_type = panic_cause_ty.unionTagType(zcu).?.toIntern(); + } +} + +fn preparePanicIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc) !void { + const pt = sema.pt; + const zcu = pt.zcu; + try preparePanic(sema, block, src); + if (zcu.panic_cause_integer_overflow == .none) { + const union_val = try pt.unionValue( + Type.fromInterned(zcu.panic_cause_type), + try pt.enumValueFieldIndex( + Type.fromInterned(zcu.panic_cause_tag_type), + @intFromEnum(PanicCauseTag.integer_overflow), + ), + Value.void, + ); + zcu.panic_cause_integer_overflow = try pt.refValue(union_val.toIntern()); } } @@ -32669,7 +32668,7 @@ fn optRefValue(sema: *Sema, opt_val: ?Value) !Value { return Value.fromInterned(try pt.intern(.{ .opt = .{ .ty = (try pt.optionalType(ptr_anyopaque_ty.toIntern())).toIntern(), .val = if (opt_val) |val| (try pt.getCoerced( - Value.fromInterned(try sema.refValue(val.toIntern())), + Value.fromInterned(try pt.refValue(val.toIntern())), ptr_anyopaque_ty, )).toIntern() else .none, } })); diff --git a/src/Zcu.zig b/src/Zcu.zig index f5f433ed9ccd..34c074d3d48e 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -214,6 +214,8 @@ free_type_references: std.ArrayListUnmanaged(u32) = .empty, panic_func_index: InternPool.Index = .none, null_stack_trace: InternPool.Index = .none, panic_cause_type: InternPool.Index = .none, +panic_cause_tag_type: InternPool.Index = .none, +panic_cause_integer_overflow: InternPool.Index = .none, generation: u32 = 0, diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index a0e90e60bd1e..6ba7e2b707f5 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -3656,6 +3656,25 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace namespace.generation = zcu.generation; } +pub fn refValue(pt: Zcu.PerThread, val: InternPool.Index) Zcu.SemaError!InternPool.Index { + const ptr_ty = (try pt.ptrTypeSema(.{ + .child = pt.zcu.intern_pool.typeOf(val), + .flags = .{ + .alignment = .none, + .is_const = true, + .address_space = .generic, + }, + })).toIntern(); + return pt.intern(.{ .ptr = .{ + .ty = ptr_ty, + .base_addr = .{ .uav = .{ + .val = val, + .orig_ty = ptr_ty, + } }, + .byte_offset = 0, + } }); +} + const Air = @import("../Air.zig"); const Allocator = std.mem.Allocator; const assert = std.debug.assert; diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 78ac35e9eb13..409ed742b43b 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -5677,46 +5677,37 @@ pub const FuncGen = struct { const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?; - fn buildSimplePanic(fg: *FuncGen, panic_cause_tag: PanicCauseTag) !void { - // TODO update this before merging the branch - _ = panic_cause_tag; - //const o = fg.ng.object; - //const zcu = o.pt.zcu; - //const ip = &zcu.intern_pool; - //const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?; - //const msg_nav = ip.getNav(msg_nav_index); - //const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu); - //const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val); - //const null_opt_addr_global = try fg.resolveNullOptUsize(); - //const target = zcu.getTarget(); - //const llvm_usize = try o.lowerType(Type.usize); - //// example: - //// call fastcc void @test2.panic( - //// ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr - //// i64 16, ; msg.len - //// ptr null, ; stack trace - //// ptr @2, ; addr (null ?usize) - //// ) - //const panic_func = zcu.funcInfo(zcu.panic_func_index); - //const panic_nav = ip.getNav(panic_func.owner_nav); - //const fn_info = zcu.typeToFunc(Type.fromInterned(panic_nav.typeOf(ip))).?; - //const panic_global = try o.resolveLlvmFunction(panic_func.owner_nav); - //_ = try fg.wip.callIntrinsicAssumeCold(); - //_ = try fg.wip.call( - // .normal, - // toLlvmCallConv(fn_info.cc, target), - // .none, - // panic_global.typeOf(&o.builder), - // panic_global.toValue(&o.builder), - // &.{ - // msg_ptr.toValue(), - // try o.builder.intValue(llvm_usize, msg_len), - // try o.builder.nullValue(.ptr), - // null_opt_addr_global.toValue(), - // }, - // "", - //); - _ = try fg.wip.callIntrinsic(.normal, .none, .trap, &.{}, &.{}, ""); + fn buildSimplePanic(fg: *FuncGen, panic_cause: InternPool.Index) !void { + const o = fg.ng.object; + const zcu = o.pt.zcu; + const ip = &zcu.intern_pool; + const cause_ptr = try o.lowerValue(panic_cause); + const null_opt_addr_global = try fg.resolveNullOptUsize(); + const target = zcu.getTarget(); + // example: + // call fastcc void @test2.panic( + // ptr @foo, ; panic_cause + // ptr null, ; stack trace + // ptr @2, ; addr (null ?usize) + // ) + const panic_func = zcu.funcInfo(zcu.panic_func_index); + const panic_nav = ip.getNav(panic_func.owner_nav); + const fn_info = zcu.typeToFunc(Type.fromInterned(panic_nav.typeOf(ip))).?; + const panic_global = try o.resolveLlvmFunction(panic_func.owner_nav); + _ = try fg.wip.callIntrinsicAssumeCold(); + _ = try fg.wip.call( + .normal, + toLlvmCallConv(fn_info.cc, target), + .none, + panic_global.typeOf(&o.builder), + panic_global.toValue(&o.builder), + &.{ + cause_ptr.toValue(), + try o.builder.nullValue(.ptr), + null_opt_addr_global.toValue(), + }, + "", + ); _ = try fg.wip.@"unreachable"(); } @@ -8340,7 +8331,7 @@ pub const FuncGen = struct { _ = try fg.wip.brCond(overflow_bit, fail_block, ok_block, .none); fg.wip.cursor = .{ .block = fail_block }; - try fg.buildSimplePanic(.integer_overflow); + try fg.buildSimplePanic(zcu.panic_cause_integer_overflow); fg.wip.cursor = .{ .block = ok_block }; return fg.wip.extractValue(results, &.{0}, ""); From 70746d580c7096938446eb47f57242edf17a9caf Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 18:58:37 -0700 Subject: [PATCH 07/21] better codegen for `@panic` with comptime-known operand --- src/Sema.zig | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 3d4844015c08..b00b44a7559d 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -7320,10 +7320,7 @@ fn callPanic( return; } const panic_cause_ty = try pt.getBuiltinType("PanicCause"); - const panic_cause = if (payload == .void_value) - try initUnionFromEnumTag(pt, panic_cause_ty, panic_cause_ty.unionTagType(zcu).?, @intFromEnum(tag)) - else - try block.addUnionInit(panic_cause_ty, @intFromEnum(tag), payload); + const panic_cause = try unionInitFromEnumTag(sema, block, call_src, panic_cause_ty, @intFromEnum(tag), payload); const panic_fn = try pt.getBuiltin("panic"); const err_return_trace = try sema.getErrorReturnTrace(block); const opt_usize_ty = try pt.optionalType(.usize_type); @@ -18311,7 +18308,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .undefined, .null, .enum_literal, - => |type_info_tag| return initUnionFromEnumTag(pt, type_info_ty, type_info_tag_ty, @intFromEnum(type_info_tag)), + => |type_info_tag| return unionInitFromEnumTag(sema, block, src, type_info_ty, @intFromEnum(type_info_tag), .void_value), + .@"fn" => { const fn_info_ty = try getInnerType(sema, block, src, type_info_ty, "Fn"); const param_info_ty = try getInnerType(sema, block, src, fn_info_ty, "Param"); @@ -20607,6 +20605,20 @@ fn unionInit( const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src); const field_ty = Type.fromInterned(zcu.typeToUnion(union_ty).?.field_types.get(ip)[field_index]); const init = try sema.coerce(block, field_ty, uncasted_init, init_src); + _ = union_ty_src; + return unionInitFromEnumTag(sema, block, init_src, union_ty, field_index, init); +} + +fn unionInitFromEnumTag( + sema: *Sema, + block: *Block, + init_src: LazySrcLoc, + union_ty: Type, + field_index: u32, + init: Air.Inst.Ref, +) !Air.Inst.Ref { + const pt = sema.pt; + const zcu = pt.zcu; if (try sema.resolveValue(init)) |init_val| { const tag_ty = union_ty.unionTagTypeHypothetical(zcu); @@ -20619,7 +20631,6 @@ fn unionInit( } try sema.requireRuntimeBlock(block, init_src, null); - _ = union_ty_src; return block.addUnionInit(union_ty, field_index, init); } @@ -38929,11 +38940,3 @@ fn getInnerType( try sema.ensureNavResolved(src, nav); return Type.fromInterned(ip.getNav(nav).status.resolved.val); } - -fn initUnionFromEnumTag(pt: Zcu.PerThread, union_ty: Type, union_tag_ty: Type, field_index: u32) !Air.Inst.Ref { - return Air.internedToRef((try pt.internUnion(.{ - .ty = union_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(union_tag_ty, field_index)).toIntern(), - .val = .void_value, - }))); -} From 61b20105e43b0db6d6f459dcb42acdda0365e0a3 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 19:34:34 -0700 Subject: [PATCH 08/21] fix crash report not using mutexes correctly --- src/crash_report.zig | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/crash_report.zig b/src/crash_report.zig index e7a18d7f60e3..6f0820b7825a 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -321,9 +321,6 @@ const PanicSwitch = struct { /// until all panicking threads have dumped their traces. var panicking = std.atomic.Value(u8).init(0); - // Locked to avoid interleaving panic messages from multiple threads. - var panic_mutex = std.Thread.Mutex{}; - /// Tracks the state of the current panic. If the code within the /// panic triggers a secondary panic, this allows us to recover. threadlocal var panic_state_raw: PanicState = .{}; @@ -391,7 +388,7 @@ const PanicSwitch = struct { state.recover_stage = .release_ref_count; - panic_mutex.lock(); + std.debug.lockStdErr(); state.recover_stage = .release_mutex; @@ -453,7 +450,7 @@ const PanicSwitch = struct { noinline fn releaseMutex(state: *volatile PanicState) noreturn { state.recover_stage = .abort; - panic_mutex.unlock(); + std.debug.unlockStdErr(); goTo(releaseRefCount, .{state}); } From e8887829cab0eb1d4a1d578efd1c75a55ab2d060 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 19:35:27 -0700 Subject: [PATCH 09/21] compile error instead of crash when root panic fn wrong --- src/Sema.zig | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Sema.zig b/src/Sema.zig index b00b44a7559d..0a66b04deb6f 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -7321,7 +7321,8 @@ fn callPanic( } const panic_cause_ty = try pt.getBuiltinType("PanicCause"); const panic_cause = try unionInitFromEnumTag(sema, block, call_src, panic_cause_ty, @intFromEnum(tag), payload); - const panic_fn = try pt.getBuiltin("panic"); + try preparePanic(sema, block, call_src); + const panic_fn = Air.internedToRef(zcu.panic_func_index); const err_return_trace = try sema.getErrorReturnTrace(block); const opt_usize_ty = try pt.optionalType(.usize_type); const null_usize = try pt.nullValue(opt_usize_ty); From 231783f2078bca02a8b861f2d750a61db0c4d581 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 20:17:21 -0700 Subject: [PATCH 10/21] update test cases to new panic API --- .../compile_errors/panic_has_source_location.zig | 7 +++++-- test/cases/safety/@alignCast misaligned.zig | 4 ++-- .../safety/@enumFromInt - no matching tag value.zig | 4 ++-- .../@errorCast error not present in destination.zig | 4 ++-- ...errorCast error union casted to disjoint set.zig | 4 ++-- test/cases/safety/@intCast to u0.zig | 4 ++-- ...FromFloat cannot fit - negative out of range.zig | 4 ++-- ...tFromFloat cannot fit - negative to unsigned.zig | 4 ++-- ...FromFloat cannot fit - positive out of range.zig | 4 ++-- ...ss zero to non-optional byte-aligned pointer.zig | 4 ++-- ...FromInt address zero to non-optional pointer.zig | 4 ++-- .../safety/@ptrFromInt with misaligned address.zig | 4 ++-- .../safety/@tagName on corrupted enum value.zig | 4 ++-- .../safety/@tagName on corrupted union value.zig | 4 ++-- .../safety/array slice sentinel mismatch vector.zig | 4 ++-- test/cases/safety/array slice sentinel mismatch.zig | 11 ++++++++--- test/cases/safety/bad union field access.zig | 13 ++++++++++--- test/cases/safety/calling panic.zig | 11 ++++++++--- .../cast []u8 to bigger slice of wrong size.zig | 4 ++-- ... integer to global error and no code matches.zig | 4 ++-- .../empty slice with sentinel out of bounds.zig | 11 ++++++++--- .../safety/exact division failure - vectors.zig | 4 ++-- test/cases/safety/exact division failure.zig | 4 ++-- test/cases/safety/for_len_mismatch.zig | 4 ++-- test/cases/safety/for_len_mismatch_three.zig | 4 ++-- .../safety/ignored expression integer overflow.zig | 4 ++-- test/cases/safety/integer addition overflow.zig | 4 ++-- .../safety/integer division by zero - vectors.zig | 4 ++-- test/cases/safety/integer division by zero.zig | 4 ++-- .../safety/integer multiplication overflow.zig | 4 ++-- test/cases/safety/integer negation overflow.zig | 4 ++-- test/cases/safety/integer subtraction overflow.zig | 4 ++-- test/cases/safety/memcpy_alias.zig | 4 ++-- test/cases/safety/memcpy_len_mismatch.zig | 4 ++-- test/cases/safety/memset_array_undefined_bytes.zig | 4 ++-- test/cases/safety/memset_array_undefined_large.zig | 4 ++-- test/cases/safety/memset_slice_undefined_bytes.zig | 4 ++-- test/cases/safety/memset_slice_undefined_large.zig | 4 ++-- test/cases/safety/modrem by zero.zig | 4 ++-- test/cases/safety/modulus by zero.zig | 4 ++-- test/cases/safety/noreturn returned.zig | 4 ++-- .../optional unwrap operator on C pointer.zig | 4 ++-- .../optional unwrap operator on null pointer.zig | 4 ++-- .../safety/out of bounds array slice by length.zig | 11 ++++++++--- test/cases/safety/out of bounds slice access.zig | 11 ++++++++--- ...pointer casting null to non-optional pointer.zig | 4 ++-- .../pointer casting to null function pointer.zig | 4 ++-- .../safety/pointer slice sentinel mismatch.zig | 11 ++++++++--- test/cases/safety/remainder division by zero.zig | 4 ++-- test/cases/safety/shift left by huge amount.zig | 4 ++-- test/cases/safety/shift right by huge amount.zig | 4 ++-- .../signed integer division overflow - vectors.zig | 4 ++-- .../safety/signed integer division overflow.zig | 4 ++-- ...tting in cast to unsigned integer - widening.zig | 4 ++-- ...eger not fitting in cast to unsigned integer.zig | 4 ++-- test/cases/safety/signed shift left overflow.zig | 4 ++-- test/cases/safety/signed shift right overflow.zig | 4 ++-- test/cases/safety/signed-unsigned vector cast.zig | 4 ++-- .../safety/slice sentinel mismatch - floats.zig | 4 ++-- .../slice sentinel mismatch - optional pointers.zig | 4 ++-- test/cases/safety/slice slice sentinel mismatch.zig | 11 ++++++++--- .../slice start index greater than end index.zig | 11 ++++++++--- ...ce with sentinel out of bounds - runtime len.zig | 11 ++++++++--- .../safety/slice with sentinel out of bounds.zig | 11 ++++++++--- .../safety/slicing null C pointer - runtime len.zig | 4 ++-- test/cases/safety/slicing null C pointer.zig | 4 ++-- ...witch else on corrupt enum value - one prong.zig | 4 ++-- .../switch else on corrupt enum value - union.zig | 4 ++-- .../safety/switch else on corrupt enum value.zig | 4 ++-- .../cases/safety/switch on corrupted enum value.zig | 4 ++-- .../safety/switch on corrupted union value.zig | 4 ++-- test/cases/safety/truncating vector cast.zig | 4 ++-- test/cases/safety/unreachable.zig | 5 ++--- ...g in cast to signed integer - same bit count.zig | 4 ++-- test/cases/safety/unsigned shift left overflow.zig | 4 ++-- test/cases/safety/unsigned shift right overflow.zig | 4 ++-- test/cases/safety/unsigned-signed vector cast.zig | 4 ++-- test/cases/safety/unwrap error switch.zig | 11 ++++++++--- test/cases/safety/unwrap error.zig | 11 ++++++++--- .../value does not fit in shortening cast - u0.zig | 4 ++-- .../value does not fit in shortening cast.zig | 4 ++-- .../safety/vector integer addition overflow.zig | 4 ++-- .../vector integer multiplication overflow.zig | 4 ++-- .../safety/vector integer negation overflow.zig | 4 ++-- .../safety/vector integer subtraction overflow.zig | 4 ++-- test/cases/safety/zero casted to error.zig | 4 ++-- 86 files changed, 255 insertions(+), 186 deletions(-) diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig index 6e9d16d76d24..c29f126c9f76 100644 --- a/test/cases/compile_errors/panic_has_source_location.zig +++ b/test/cases/compile_errors/panic_has_source_location.zig @@ -6,7 +6,10 @@ export fn foo() void { @panic("oh no"); } -pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn { + _ = cause; + _ = ert; + _ = ra; @compileError("panic"); } @@ -14,4 +17,4 @@ pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { // backend=stage2 // target=native // -// :10:5: error: panic +// :13:5: error: panic diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig index ade27c2747a8..b514810730ca 100644 --- a/test/cases/safety/@alignCast misaligned.zig +++ b/test/cases/safety/@alignCast misaligned.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "incorrect alignment")) { + if (cause == .incorrect_alignment) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig index 5051869cc0cb..10f526770294 100644 --- a/test/cases/safety/@enumFromInt - no matching tag value.zig +++ b/test/cases/safety/@enumFromInt - no matching tag value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { + if (cause == .invalid_enum_value) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig index ff86e1f78382..73b87ad20e65 100644 --- a/test/cases/safety/@errorCast error not present in destination.zig +++ b/test/cases/safety/@errorCast error not present in destination.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { + if (cause == .invalid_error_code) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig index c9da2fc636ae..bdb2d80760cd 100644 --- a/test/cases/safety/@errorCast error union casted to disjoint set.zig +++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { + if (cause == .invalid_error_code) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig index a33da87f0fa8..daf5069e61a8 100644 --- a/test/cases/safety/@intCast to u0.zig +++ b/test/cases/safety/@intCast to u0.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig index a5a8d831b337..d029f9034302 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { + if (cause == .integer_part_out_of_bounds) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig index 1bf1a667659f..ea2365ea6dd1 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { + if (cause == .integer_part_out_of_bounds) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig index 15a9fa7ad188..1bdc23982a17 100644 --- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { + if (cause == .integer_part_out_of_bounds) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig index f8c448855e34..2788a31fd915 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { + if (cause == .cast_to_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig index c9ae253df7ba..81e450011573 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { + if (cause == .cast_to_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig index 3952ab9baa2f..2c291f9ad355 100644 --- a/test/cases/safety/@ptrFromInt with misaligned address.zig +++ b/test/cases/safety/@ptrFromInt with misaligned address.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "incorrect alignment")) { + if (cause == .incorrect_alignment) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig index e23cd1fcf692..a89dc72a9768 100644 --- a/test/cases/safety/@tagName on corrupted enum value.zig +++ b/test/cases/safety/@tagName on corrupted enum value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { + if (cause == .invalid_enum_value) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig index 09d8276d2339..799a9c6a177f 100644 --- a/test/cases/safety/@tagName on corrupted union value.zig +++ b/test/cases/safety/@tagName on corrupted union value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { + if (cause == .invalid_enum_value) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig index da20d988691f..aea05a6b4144 100644 --- a/test/cases/safety/array slice sentinel mismatch vector.zig +++ b/test/cases/safety/array slice sentinel mismatch vector.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) { + if (cause == .sentinel_mismatch_other) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig index fc196186732d..2e9bcf936614 100644 --- a/test/cases/safety/array slice sentinel mismatch.zig +++ b/test/cases/safety/array slice sentinel mismatch.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .sentinel_mismatch_usize => |info| { + if (info.expected == 0 and info.found == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig index c6706d41764d..d73897f0f375 100644 --- a/test/cases/safety/bad union field access.zig +++ b/test/cases/safety/bad union field access.zig @@ -1,9 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { - std.process.exit(0); + switch (cause) { + .inactive_union_field => |info| { + if (std.mem.eql(u8, info.active, "int") and + std.mem.eql(u8, info.accessed, "float")) + { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig index 832bc5f19ad2..d77f0dd91161 100644 --- a/test/cases/safety/calling panic.zig +++ b/test/cases/safety/calling panic.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "oh no")) { - std.process.exit(0); + switch (cause) { + .explicit_call => |message| { + if (std.mem.eql(u8, message, "oh no")) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 a72b2fcca2ca..50dac0411c5a 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { + if (cause == .exact_division_remainder) { std.process.exit(0); } std.process.exit(1); 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 61daf07a2ba2..f6c5410a7b2a 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { + if (cause == .invalid_error_code) { std.process.exit(0); } std.process.exit(1); 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 69201fde307c..2c0a4ebb403a 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,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .index_out_of_bounds => |info| { + if (info.index == 1 and info.len == 0) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig index c5df2b276f17..8d65d833e134 100644 --- a/test/cases/safety/exact division failure - vectors.zig +++ b/test/cases/safety/exact division failure - vectors.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { + if (cause == .exact_division_remainder) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig index cdf1b1fb8d31..8fa31d6ee050 100644 --- a/test/cases/safety/exact division failure.zig +++ b/test/cases/safety/exact division failure.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { + if (cause == .exact_division_remainder) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig index ee21b947d7ee..37a0761ee92e 100644 --- a/test/cases/safety/for_len_mismatch.zig +++ b/test/cases/safety/for_len_mismatch.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { + if (cause == .for_len_mismatch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig index 70f854def51f..3f1f1ac23006 100644 --- a/test/cases/safety/for_len_mismatch_three.zig +++ b/test/cases/safety/for_len_mismatch_three.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { + if (cause == .for_len_mismatch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig index f8e3f0bf0aa6..1ddb3588bccf 100644 --- a/test/cases/safety/ignored expression integer overflow.zig +++ b/test/cases/safety/ignored expression integer overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig index 4f7c5b2cb3f5..8aea6c761624 100644 --- a/test/cases/safety/integer addition overflow.zig +++ b/test/cases/safety/integer addition overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig index 6e2af616b909..3ac58efd313d 100644 --- a/test/cases/safety/integer division by zero - vectors.zig +++ b/test/cases/safety/integer division by zero - vectors.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { + if (cause == .divide_by_zero) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig index 0d1b79d26d8f..7f14acc9a4b8 100644 --- a/test/cases/safety/integer division by zero.zig +++ b/test/cases/safety/integer division by zero.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { + if (cause == .divide_by_zero) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig index 641801277dbd..d90d65ed86d6 100644 --- a/test/cases/safety/integer multiplication overflow.zig +++ b/test/cases/safety/integer multiplication overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig index 3d4c134c4a68..9a569b5338c8 100644 --- a/test/cases/safety/integer negation overflow.zig +++ b/test/cases/safety/integer negation overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig index 84a16f55b870..a6591dd9ec42 100644 --- a/test/cases/safety/integer subtraction overflow.zig +++ b/test/cases/safety/integer subtraction overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig index d87a7bf6aa4d..191a37f8eb77 100644 --- a/test/cases/safety/memcpy_alias.zig +++ b/test/cases/safety/memcpy_alias.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "@memcpy arguments alias")) { + if (cause == .memcpy_alias) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig index 6ca36abccbbf..aa5bb92732e8 100644 --- a/test/cases/safety/memcpy_len_mismatch.zig +++ b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) { + if (cause == .memcpy_len_mismatch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig index e0ce2dac0443..c1c86df1aa54 100644 --- a/test/cases/safety/memset_array_undefined_bytes.zig +++ b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig index dbc1cf442024..3cab2f4c5fce 100644 --- a/test/cases/safety/memset_array_undefined_large.zig +++ b/test/cases/safety/memset_array_undefined_large.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig index 4214b5db4b76..d6a7e3e5cd95 100644 --- a/test/cases/safety/memset_slice_undefined_bytes.zig +++ b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig index d1f4f651d33b..a5e572eefdbe 100644 --- a/test/cases/safety/memset_slice_undefined_large.zig +++ b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig index f201062c0e8f..16616f4801f9 100644 --- a/test/cases/safety/modrem by zero.zig +++ b/test/cases/safety/modrem by zero.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { + if (cause == .divide_by_zero) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig index 6714458979d0..454b1cd43218 100644 --- a/test/cases/safety/modulus by zero.zig +++ b/test/cases/safety/modulus by zero.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { + if (cause == .divide_by_zero) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig index c3c30af37ee4..ac413089e77e 100644 --- a/test/cases/safety/noreturn returned.zig +++ b/test/cases/safety/noreturn returned.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "'noreturn' function returned")) { + if (cause == .noreturn_returned) { std.process.exit(0); } std.process.exit(1); 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 bd3313265a50..59ffe381a483 100644 --- a/test/cases/safety/optional unwrap operator on C pointer.zig +++ b/test/cases/safety/optional unwrap operator on C pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { + if (cause == .unwrap_null) { std.process.exit(0); } std.process.exit(1); 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 9dda4d0a9e07..9b09d63f7bbb 100644 --- a/test/cases/safety/optional unwrap operator on null pointer.zig +++ b/test/cases/safety/optional unwrap operator on null pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { + if (cause == .unwrap_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig index 62768abebf60..9ad18972f849 100644 --- a/test/cases/safety/out of bounds array slice by length.zig +++ b/test/cases/safety/out of bounds array slice by length.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) { - std.process.exit(0); + switch (cause) { + .index_out_of_bounds => |info| { + if (info.index == 16 and info.len == 5) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig index b4c87948a5ce..7b7ac0f8fa26 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out of bounds slice access.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .index_out_of_bounds => |info| { + if (info.index == 4 and info.len == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 fdf8dc17ce27..ad8921ae92df 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { + if (cause == .cast_to_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig index 8f399b66dc27..364f66ab1924 100644 --- a/test/cases/safety/pointer casting to null function pointer.zig +++ b/test/cases/safety/pointer casting to null function pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { + if (cause == .cast_to_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig index 3972528edf42..7d79144fcf8a 100644 --- a/test/cases/safety/pointer slice sentinel mismatch.zig +++ b/test/cases/safety/pointer slice sentinel mismatch.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .sentinel_mismatch_usize => |info| { + if (info.expected == 0 and info.found == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig index 3dc97f6e16fd..9fee0aa13ac5 100644 --- a/test/cases/safety/remainder division by zero.zig +++ b/test/cases/safety/remainder division by zero.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { + if (cause == .divide_by_zero) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig index a038c0ee4442..09425b2cc1d2 100644 --- a/test/cases/safety/shift left by huge amount.zig +++ b/test/cases/safety/shift left by huge amount.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { + if (cause == .shift_rhs_too_big) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig index ced81d948d48..b02e2a01af27 100644 --- a/test/cases/safety/shift right by huge amount.zig +++ b/test/cases/safety/shift right by huge amount.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { + if (cause == .shift_rhs_too_big) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig index 6346d9f1a1dd..0da140b8f2de 100644 --- a/test/cases/safety/signed integer division overflow - vectors.zig +++ b/test/cases/safety/signed integer division overflow - vectors.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig index 9d1014ceec08..576e3ef7aa50 100644 --- a/test/cases/safety/signed integer division overflow.zig +++ b/test/cases/safety/signed integer division overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); 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 87c812eddc20..762719df8165 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { + if (cause == .negative_to_unsigned) { std.process.exit(0); } std.process.exit(1); 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 5d8c3f88c8a3..765a50d5a562 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { + if (cause == .negative_to_unsigned) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig index f9a4db81ce92..148d79ca4d61 100644 --- a/test/cases/safety/signed shift left overflow.zig +++ b/test/cases/safety/signed shift left overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "left shift overflowed bits")) { + if (cause == .shl_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig index 7d71b9ffbde3..f89f57a132a6 100644 --- a/test/cases/safety/signed shift right overflow.zig +++ b/test/cases/safety/signed shift right overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "right shift overflowed bits")) { + if (cause == .shr_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig index 2e3b4d25d52d..2dee04d1bfa8 100644 --- a/test/cases/safety/signed-unsigned vector cast.zig +++ b/test/cases/safety/signed-unsigned vector cast.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { + if (cause == .negative_to_unsigned) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig index 19b9b86c3ba8..71b32e0c8a50 100644 --- a/test/cases/safety/slice sentinel mismatch - floats.zig +++ b/test/cases/safety/slice sentinel mismatch - floats.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) { + if (cause == .sentinel_mismatch_other) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig index a3b4a98575e6..5e69a1d35032 100644 --- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig +++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) { + if (cause == .sentinel_mismatch_other) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig index 635706b2c58a..7f90b9edbfa4 100644 --- a/test/cases/safety/slice slice sentinel mismatch.zig +++ b/test/cases/safety/slice slice sentinel mismatch.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .sentinel_mismatch_usize => |info| { + if (info.expected == 0 and info.found == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig index 83d489ab5699..5cdf1e46e947 100644 --- a/test/cases/safety/slice start index greater than end index.zig +++ b/test/cases/safety/slice start index greater than end index.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { - std.process.exit(0); + switch (cause) { + .start_index_greater_than_end => |info| { + if (info.start == 10 and info.end == 1) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 abb3cc42f092..09d8fa32a579 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,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .index_out_of_bounds => |info| { + if (info.index == 5 and info.len == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 1683dc9d3f32..1ec069865767 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice with sentinel out of bounds.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, 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); + switch (cause) { + .index_out_of_bounds => |info| { + if (info.index == 5 and info.len == 4) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 dd73a5011205..d4ebbdff18fd 100644 --- a/test/cases/safety/slicing null C pointer - runtime len.zig +++ b/test/cases/safety/slicing null C pointer - runtime len.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { + if (cause == .unwrap_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig index 862f2dcfdba6..b3e50b0ebf1e 100644 --- a/test/cases/safety/slicing null C pointer.zig +++ b/test/cases/safety/slicing null C pointer.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { + if (cause == .unwrap_null) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig index c11227c3bee8..bc8321a34693 100644 --- a/test/cases/safety/switch else on corrupt enum value - one prong.zig +++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { + if (cause == .corrupt_switch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig index a63c78597e66..4f6e00c85a0a 100644 --- a/test/cases/safety/switch else on corrupt enum value - union.zig +++ b/test/cases/safety/switch else on corrupt enum value - union.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { + if (cause == .corrupt_switch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig index 7e050838c086..1d3821739920 100644 --- a/test/cases/safety/switch else on corrupt enum value.zig +++ b/test/cases/safety/switch else on corrupt enum value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { + if (cause == .corrupt_switch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig index f89076191172..159140180881 100644 --- a/test/cases/safety/switch on corrupted enum value.zig +++ b/test/cases/safety/switch on corrupted enum value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { + if (cause == .corrupt_switch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig index fc93c9d6e7f0..1ae72fcbfbf3 100644 --- a/test/cases/safety/switch on corrupted union value.zig +++ b/test/cases/safety/switch on corrupted union value.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { + if (cause == .corrupt_switch) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig index ae76d4dec125..32fb40755597 100644 --- a/test/cases/safety/truncating vector cast.zig +++ b/test/cases/safety/truncating vector cast.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig index 818d7e31a562..b12b1a722f88 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,9 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - _ = ret_addr; - if (std.mem.eql(u8, message, "reached unreachable code")) { + if (cause == .reached_unreachable) { std.process.exit(0); } std.process.exit(1); 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 9bd4c4200702..937d52256915 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig index d38d8f6ecf06..53fe91c9fb98 100644 --- a/test/cases/safety/unsigned shift left overflow.zig +++ b/test/cases/safety/unsigned shift left overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "left shift overflowed bits")) { + if (cause == .shl_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig index 121797a17d4c..a5389797fc3b 100644 --- a/test/cases/safety/unsigned shift right overflow.zig +++ b/test/cases/safety/unsigned shift right overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "right shift overflowed bits")) { + if (cause == .shr_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig index 32676f7c1cb6..aab2f5ae168a 100644 --- a/test/cases/safety/unsigned-signed vector cast.zig +++ b/test/cases/safety/unsigned-signed vector cast.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig index 0723a9fb246a..dd587c48653c 100644 --- a/test/cases/safety/unwrap error switch.zig +++ b/test/cases/safety/unwrap error switch.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { - std.process.exit(0); + switch (cause) { + .unwrap_error => |err| { + if (err == error.Whatever) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig index e2d7ea725b8b..a2ac8f50461c 100644 --- a/test/cases/safety/unwrap error.zig +++ b/test/cases/safety/unwrap error.zig @@ -1,9 +1,14 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { - std.process.exit(0); + switch (cause) { + .unwrap_error => |err| { + if (err == error.Whatever) { + std.process.exit(0); + } + }, + else => {}, } std.process.exit(1); } 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 ec111a2caedd..d06d1cf440d4 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); 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 a5ea41659e86..3f55f40f963e 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,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { + if (cause == .cast_truncated_data) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig index 21c26eeb4e47..3e3145db862d 100644 --- a/test/cases/safety/vector integer addition overflow.zig +++ b/test/cases/safety/vector integer addition overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig index 8678eccec6fe..eceb507efa16 100644 --- a/test/cases/safety/vector integer multiplication overflow.zig +++ b/test/cases/safety/vector integer multiplication overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig index 5f8becad177c..5f408dab8b6d 100644 --- a/test/cases/safety/vector integer negation overflow.zig +++ b/test/cases/safety/vector integer negation overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig index 82c034212104..c858ac5e341f 100644 --- a/test/cases/safety/vector integer subtraction overflow.zig +++ b/test/cases/safety/vector integer subtraction overflow.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { + if (cause == .integer_overflow) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig index 78340db3163c..591e4b62ef9e 100644 --- a/test/cases/safety/zero casted to error.zig +++ b/test/cases/safety/zero casted to error.zig @@ -1,8 +1,8 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { + if (cause == .invalid_error_code) { std.process.exit(0); } std.process.exit(1); From fcfbedc2f06ba5700092a2cb444261133944be01 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 25 Sep 2024 20:39:18 -0700 Subject: [PATCH 11/21] work around riscv64 backend deficiencies --- lib/std/builtin.zig | 20 ++++++++++++++++++++ lib/std/debug.zig | 5 +++++ 2 files changed, 25 insertions(+) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 4edcebad53ad..704d89dacea5 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -833,6 +833,10 @@ pub const PanicCause = union(enum) { pub fn panicSentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { @branchHint(.cold); + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + @trap(); + } switch (@typeInfo(@TypeOf(expected))) { .int => |int| switch (int.signedness) { .unsigned => if (int.bits <= @bitSizeOf(usize)) panic(.{ .sentinel_mismatch_usize = .{ @@ -864,11 +868,19 @@ pub fn panicSentinelMismatch(expected: anytype, found: @TypeOf(expected)) noretu pub fn panicUnwrapError(ert: ?*StackTrace, err: anyerror) noreturn { @branchHint(.cold); + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + @trap(); + } panic(.{ .unwrap_error = err }, ert, @returnAddress()); } pub fn panicOutOfBounds(index: usize, len: usize) noreturn { @branchHint(.cold); + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + @trap(); + } panic(.{ .index_out_of_bounds = .{ .index = index, .len = len, @@ -877,6 +889,10 @@ pub fn panicOutOfBounds(index: usize, len: usize) noreturn { pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { @branchHint(.cold); + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + @trap(); + } panic(.{ .start_index_greater_than_end = .{ .start = start, .end = end, @@ -885,6 +901,10 @@ pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { pub fn panicInactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { @branchHint(.cold); + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + @trap(); + } panic(.{ .inactive_union_field = .{ .active = @tagName(active), .accessed = @tagName(accessed), diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 7bfc6b321e2b..98bf6b1fd42d 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -629,6 +629,11 @@ pub fn fmtPanicCause(buffer: []u8, cause: std.builtin.PanicCause) usize { }, .sentinel_mismatch_other => i += fmtBuf(buffer[i..], "sentinel mismatch"), .unwrap_error => |err| { + if (builtin.zig_backend == .stage2_riscv64) { + // https://github.com/ziglang/zig/issues/21519 + i += fmtBuf(buffer[i..], "attempt to unwrap error"); + return i; + } i += fmtBuf(buffer[i..], "attempt to unwrap error: "); i += fmtBuf(buffer[i..], @errorName(err)); }, From c9c080a187ae1839a5531d3d95c1080f38721229 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 14:24:18 -0700 Subject: [PATCH 12/21] embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own. --- lib/compiler_rt/common.zig | 11 +- lib/std/builtin.zig | 166 +++++----------------------- lib/std/debug.zig | 181 +++++-------------------------- lib/std/debug/FormattedPanic.zig | 45 ++++++++ lib/std/debug/SimplePanic.zig | 86 +++++++++++++++ src/Sema.zig | 143 ++++++++++++------------ src/Zcu.zig | 29 ++++- src/crash_report.zig | 49 ++++----- 8 files changed, 309 insertions(+), 401 deletions(-) create mode 100644 lib/std/debug/FormattedPanic.zig create mode 100644 lib/std/debug/SimplePanic.zig diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index 8a1055267da5..db2a55445e00 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -75,11 +75,14 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) { 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(cause: std.builtin.PanicCause, error_return_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn { +// Avoid dragging in the runtime safety mechanisms into this .o file, unless +// we're trying to test compiler-rt. +pub const Panic = if (builtin.is_test) std.debug.FormattedPanic else struct {}; + +/// To be deleted after zig1.wasm is updated. +pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn { if (builtin.is_test) { - std.debug.defaultPanic(cause, error_return_trace, ret_addr orelse @returnAddress()); + std.debug.defaultPanic(msg, error_return_trace, ret_addr orelse @returnAddress()); } else { unreachable; } diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 704d89dacea5..5d3eca5f1e42 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -761,11 +761,10 @@ pub const TestFn = struct { func: *const fn () anyerror!void, }; -/// 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 (PanicCause, ?*StackTrace, ?usize) noreturn; +/// Deprecated, use the `Panic` namespace instead. +pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn; -/// The entry point for auto-generated calls by the compiler. +/// Deprecated, use the `Panic` namespace instead. pub const panic: PanicFn = if (@hasDecl(root, "panic")) root.panic else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) @@ -773,143 +772,28 @@ else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) else std.debug.defaultPanic; -/// This data structure is used by the Zig language code generation and -/// therefore must be kept in sync with the compiler implementation. -pub const PanicCause = union(enum) { - reached_unreachable, - unwrap_null, - cast_to_null, - incorrect_alignment, - invalid_error_code, - cast_truncated_data, - negative_to_unsigned, - integer_overflow, - shl_overflow, - shr_overflow, - divide_by_zero, - exact_division_remainder, - inactive_union_field: InactiveUnionField, - integer_part_out_of_bounds, - corrupt_switch, - shift_rhs_too_big, - invalid_enum_value, - sentinel_mismatch_usize: SentinelMismatchUsize, - sentinel_mismatch_other, - unwrap_error: anyerror, - index_out_of_bounds: IndexOutOfBounds, - start_index_greater_than_end: StartIndexGreaterThanEnd, - for_len_mismatch, - memcpy_len_mismatch, - memcpy_alias, - noreturn_returned, - explicit_call: []const u8, - sentinel_mismatch_isize: SentinelMismatchIsize, - - pub const IndexOutOfBounds = struct { - index: usize, - len: usize, - }; - - pub const StartIndexGreaterThanEnd = struct { - start: usize, - end: usize, - }; - - pub const SentinelMismatchUsize = struct { - expected: usize, - found: usize, - }; - - pub const SentinelMismatchIsize = struct { - expected: isize, - found: isize, - }; - - pub const InactiveUnionField = struct { - active: []const u8, - accessed: []const u8, - }; -}; - -pub fn panicSentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { - @branchHint(.cold); - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - @trap(); - } - switch (@typeInfo(@TypeOf(expected))) { - .int => |int| switch (int.signedness) { - .unsigned => if (int.bits <= @bitSizeOf(usize)) panic(.{ .sentinel_mismatch_usize = .{ - .expected = expected, - .found = found, - } }, null, @returnAddress()), - .signed => if (int.bits <= @bitSizeOf(isize)) panic(.{ .sentinel_mismatch_isize = .{ - .expected = expected, - .found = found, - } }, null, @returnAddress()), - }, - .@"enum" => |info| switch (@typeInfo(info.tag_type)) { - .int => |int| switch (int.signedness) { - .unsigned => if (int.bits <= @bitSizeOf(usize)) panic(.{ .sentinel_mismatch_usize = .{ - .expected = @intFromEnum(expected), - .found = @intFromEnum(found), - } }, null, @returnAddress()), - .signed => if (int.bits <= @bitSizeOf(isize)) panic(.{ .sentinel_mismatch_isize = .{ - .expected = @intFromEnum(expected), - .found = @intFromEnum(found), - } }, null, @returnAddress()), - }, - else => comptime unreachable, - }, - else => {}, - } - panic(.sentinel_mismatch_other, null, @returnAddress()); -} - -pub fn panicUnwrapError(ert: ?*StackTrace, err: anyerror) noreturn { - @branchHint(.cold); - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - @trap(); - } - panic(.{ .unwrap_error = err }, ert, @returnAddress()); -} - -pub fn panicOutOfBounds(index: usize, len: usize) noreturn { - @branchHint(.cold); - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - @trap(); - } - panic(.{ .index_out_of_bounds = .{ - .index = index, - .len = len, - } }, null, @returnAddress()); -} - -pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn { - @branchHint(.cold); - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - @trap(); - } - panic(.{ .start_index_greater_than_end = .{ - .start = start, - .end = end, - } }, null, @returnAddress()); -} - -pub fn panicInactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { - @branchHint(.cold); - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - @trap(); - } - panic(.{ .inactive_union_field = .{ - .active = @tagName(active), - .accessed = @tagName(accessed), - } }, null, @returnAddress()); -} +/// This namespace is used by the Zig compiler to emit various kinds of safety +/// panics. These can be overridden by making a public `Panic` namespace in the +/// root source file. +pub const Panic: type = if (@hasDecl(root, "Panic")) + root.Panic +else if (std.builtin.zig_backend == .stage2_riscv64) + std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519 +else + std.debug.FormattedPanic; + +/// To be deleted after zig1.wasm is updated. +pub const panicSentinelMismatch = Panic.sentinelMismatch; +/// To be deleted after zig1.wasm is updated. +pub const panicUnwrapError = Panic.unwrapError; +/// To be deleted after zig1.wasm is updated. +pub const panicOutOfBounds = Panic.outOfBounds; +/// To be deleted after zig1.wasm is updated. +pub const panicStartGreaterThanEnd = Panic.startGreaterThanEnd; +/// To be deleted after zig1.wasm is updated. +pub const panicInactiveUnionField = Panic.inactiveUnionField; +/// To be deleted after zig1.wasm is updated. +pub const panic_messages = Panic.messages; pub noinline fn returnError(st: *StackTrace) void { @branchHint(.unlikely); diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 98bf6b1fd42d..0cb201373a73 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -21,6 +21,9 @@ pub const SelfInfo = @import("debug/SelfInfo.zig"); pub const Info = @import("debug/Info.zig"); pub const Coverage = @import("debug/Coverage.zig"); +pub const FormattedPanic = @import("debug/FormattedPanic.zig"); +pub const SimplePanic = @import("debug/SimplePanic.zig"); + /// Unresolved source locations can be represented with a single `usize` that /// corresponds to a virtual memory address of the program counter. Combined /// with debug information, those values can be converted into a resolved @@ -408,10 +411,16 @@ pub fn assertReadable(slice: []const volatile u8) void { for (slice) |*byte| _ = byte.*; } +/// By including a call to this function, the caller gains an error return trace +/// secret parameter, making `@errorReturnTrace()` more useful. This is not +/// necessary if the function already contains a call to an errorable function +/// elsewhere. +pub fn errorReturnTraceHelper() anyerror!void {} + /// Equivalent to `@panic` but with a formatted message. pub fn panic(comptime format: []const u8, args: anytype) noreturn { @branchHint(.cold); - + errorReturnTraceHelper() catch unreachable; panicExtra(@errorReturnTrace(), @returnAddress(), format, args); } @@ -437,7 +446,7 @@ pub fn panicExtra( break :blk &buf; }, }; - std.builtin.panic(.{ .explicit_call = msg }, trace, ret_addr); + std.builtin.Panic.call(msg, trace, ret_addr); } /// Non-zero whenever the program triggered a panic. @@ -448,11 +457,9 @@ var panicking = std.atomic.Value(u8).init(0); /// This is used to catch and handle panics triggered by the panic handler. threadlocal var panic_stage: usize = 0; -// Dumps a stack trace to standard error, then aborts. -// -// This function avoids a dependency on formatted printing. +/// Dumps a stack trace to standard error, then aborts. pub fn defaultPanic( - cause: std.builtin.PanicCause, + msg: []const u8, error_return_trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, ) noreturn { @@ -471,18 +478,6 @@ pub fn defaultPanic( @trap(); } - if (builtin.zig_backend == .stage2_riscv64) { - var buffer: [1000]u8 = undefined; - var i: usize = 0; - i += fmtPanicCause(buffer[i..], cause); - buffer[i] = '\n'; - i += 1; - const msg = buffer[0..i]; - lockStdErr(); - io.getStdErr().writeAll(msg) catch {}; - @trap(); - } - switch (builtin.os.tag) { .freestanding => { @trap(); @@ -490,14 +485,10 @@ pub fn defaultPanic( .uefi => { const uefi = std.os.uefi; - var buffer: [1000]u8 = undefined; - var i: usize = 0; - i += fmtBuf(buffer[i..], "panic: "); - i += fmtPanicCause(buffer[i..], cause); - i += fmtBuf(buffer[i..], "\r\n\x00"); - var utf16_buffer: [1000]u16 = undefined; - const len = std.unicode.utf8ToUtf16Le(&utf16_buffer, buffer[0..i]) catch 0; + const len_minus_3 = std.unicode.utf8ToUtf16Le(&utf16_buffer, msg) catch 0; + utf16_buffer[len_minus_3][0..3].* = .{ '\r', '\n', 0 }; + const len = len_minus_3 + 3; const exit_msg = utf16_buffer[0 .. len - 1 :0]; // Output to both std_err and con_out, as std_err is easier @@ -521,15 +512,11 @@ pub fn defaultPanic( }, .cuda, .amdhsa => std.posix.abort(), .plan9 => { - var buffer: [1000]u8 = undefined; - comptime assert(buffer.len > std.os.plan9.ERRMAX); - var i: usize = 0; - i += fmtPanicCause(buffer[i..], cause); - buffer[i] = '\n'; - i += 1; - const len = @min(i, std.os.plan9.ERRMAX - 1); - buffer[len] = 0; - std.os.plan9.exits(buffer[0..len :0]); + var status: [std.os.plan9.ERRMAX]u8 = undefined; + const len = @min(msg.len, status.len - 1); + @memcpy(status[0..len], msg[0..len]); + status[len] = 0; + std.os.plan9.exits(status[0..len :0]); }, else => {}, } @@ -548,26 +535,18 @@ pub fn defaultPanic( _ = panicking.fetchAdd(1, .seq_cst); { - // This code avoids a dependency on formatted printing, the writer interface, - // and limits to only 1 syscall made to print the panic message to stderr. - var buffer: [0x1000]u8 = undefined; - var i: usize = 0; + lockStdErr(); + defer unlockStdErr(); + + const stderr = io.getStdErr().writer(); if (builtin.single_threaded) { - i += fmtBuf(buffer[i..], "panic: "); + stderr.print("panic: ", .{}) catch posix.abort(); } else { - i += fmtBuf(buffer[i..], "thread "); - i += fmtInt10(buffer[i..], std.Thread.getCurrentId()); - i += fmtBuf(buffer[i..], " panic: "); + const current_thread_id = std.Thread.getCurrentId(); + stderr.print("thread {} panic: ", .{current_thread_id}) catch posix.abort(); } - i += fmtPanicCause(buffer[i..], cause); - buffer[i] = '\n'; - i += 1; - const msg = buffer[0..i]; + stderr.print("{s}\n", .{msg}) catch posix.abort(); - lockStdErr(); - defer unlockStdErr(); - - io.getStdErr().writeAll(msg) catch posix.abort(); if (error_return_trace) |t| dumpStackTrace(t.*); dumpCurrentStackTrace(first_trace_addr orelse @returnAddress()); } @@ -588,108 +567,6 @@ pub fn defaultPanic( posix.abort(); } -pub fn fmtPanicCause(buffer: []u8, cause: std.builtin.PanicCause) usize { - var i: usize = 0; - - switch (cause) { - .reached_unreachable => i += fmtBuf(buffer[i..], "reached unreachable code"), - .unwrap_null => i += fmtBuf(buffer[i..], "attempt to use null value"), - .cast_to_null => i += fmtBuf(buffer[i..], "cast causes pointer to be null"), - .incorrect_alignment => i += fmtBuf(buffer[i..], "incorrect alignment"), - .invalid_error_code => i += fmtBuf(buffer[i..], "invalid error code"), - .cast_truncated_data => i += fmtBuf(buffer[i..], "integer cast truncated bits"), - .negative_to_unsigned => i += fmtBuf(buffer[i..], "attempt to cast negative value to unsigned integer"), - .integer_overflow => i += fmtBuf(buffer[i..], "integer overflow"), - .shl_overflow => i += fmtBuf(buffer[i..], "left shift overflowed bits"), - .shr_overflow => i += fmtBuf(buffer[i..], "right shift overflowed bits"), - .divide_by_zero => i += fmtBuf(buffer[i..], "division by zero"), - .exact_division_remainder => i += fmtBuf(buffer[i..], "exact division produced remainder"), - .inactive_union_field => |info| { - i += fmtBuf(buffer[i..], "access of union field '"); - i += fmtBuf(buffer[i..], info.accessed); - i += fmtBuf(buffer[i..], "' while field '"); - i += fmtBuf(buffer[i..], info.active); - i += fmtBuf(buffer[i..], "' is active"); - }, - .integer_part_out_of_bounds => i += fmtBuf(buffer[i..], "integer part of floating point value out of bounds"), - .corrupt_switch => i += fmtBuf(buffer[i..], "switch on corrupt value"), - .shift_rhs_too_big => i += fmtBuf(buffer[i..], "shift amount is greater than the type size"), - .invalid_enum_value => i += fmtBuf(buffer[i..], "invalid enum value"), - .sentinel_mismatch_usize => |mm| { - i += fmtBuf(buffer[i..], "sentinel mismatch: expected "); - i += fmtInt10(buffer[i..], mm.expected); - i += fmtBuf(buffer[i..], ", found "); - i += fmtInt10(buffer[i..], mm.found); - }, - .sentinel_mismatch_isize => |mm| { - i += fmtBuf(buffer[i..], "sentinel mismatch: expected "); - i += fmtInt10s(buffer[i..], mm.expected); - i += fmtBuf(buffer[i..], ", found "); - i += fmtInt10s(buffer[i..], mm.found); - }, - .sentinel_mismatch_other => i += fmtBuf(buffer[i..], "sentinel mismatch"), - .unwrap_error => |err| { - if (builtin.zig_backend == .stage2_riscv64) { - // https://github.com/ziglang/zig/issues/21519 - i += fmtBuf(buffer[i..], "attempt to unwrap error"); - return i; - } - i += fmtBuf(buffer[i..], "attempt to unwrap error: "); - i += fmtBuf(buffer[i..], @errorName(err)); - }, - .index_out_of_bounds => |oob| { - i += fmtBuf(buffer[i..], "index "); - i += fmtInt10(buffer[i..], oob.index); - i += fmtBuf(buffer[i..], " exceeds length "); - i += fmtInt10(buffer[i..], oob.len); - }, - .start_index_greater_than_end => |oob| { - i += fmtBuf(buffer[i..], "start index "); - i += fmtInt10(buffer[i..], oob.start); - i += fmtBuf(buffer[i..], " exceeds end index "); - i += fmtInt10(buffer[i..], oob.end); - }, - .for_len_mismatch => i += fmtBuf(buffer[i..], "for loop over objects with non-equal lengths"), - .memcpy_len_mismatch => i += fmtBuf(buffer[i..], "@memcpy arguments have non-equal lengths"), - .memcpy_alias => i += fmtBuf(buffer[i..], "@memcpy arguments alias"), - .noreturn_returned => i += fmtBuf(buffer[i..], "'noreturn' function returned"), - .explicit_call => |msg| i += fmtBuf(buffer[i..], msg), - } - - return i; -} - -fn fmtBuf(out_buf: []u8, s: []const u8) usize { - @memcpy(out_buf[0..s.len], s); - return s.len; -} - -fn fmtInt10s(out_buf: []u8, integer_value: isize) usize { - if (integer_value < 0) { - out_buf[0] = '-'; - return 1 + fmtInt10(out_buf[1..], @abs(integer_value)); - } else { - return fmtInt10(out_buf, @abs(integer_value)); - } -} - -fn fmtInt10(out_buf: []u8, integer_value: usize) usize { - var tmp_buf: [50]u8 = undefined; - var i: usize = tmp_buf.len; - var a: usize = integer_value; - - while (true) { - i -= 1; - tmp_buf[i] = '0' + @as(u8, @intCast(a % 10)); - a /= 10; - if (a == 0) break; - } - - const result = tmp_buf[i..]; - @memcpy(out_buf[0..result.len], result); - return result.len; -} - /// Must be called only after adding 1 to `panicking`. There are three callsites. fn waitForOtherThreadToFinishPanicking() void { if (panicking.fetchSub(1, .seq_cst) != 1) { diff --git a/lib/std/debug/FormattedPanic.zig b/lib/std/debug/FormattedPanic.zig new file mode 100644 index 000000000000..0ad6ea696c9b --- /dev/null +++ b/lib/std/debug/FormattedPanic.zig @@ -0,0 +1,45 @@ +//! This namespace is the default one used by the Zig compiler to emit various +//! kinds of safety panics, due to the logic in `std.builtin.Panic`. +//! +//! Since Zig does not have interfaces, this file serves as an example template +//! for users to provide their own alternative panic handling. +//! +//! As an alternative, see `std.debug.SimplePanic`. + +const std = @import("../std.zig"); + +/// Dumps a stack trace to standard error, then aborts. +/// +/// Explicit calls to `@panic` lower to calling this function. +pub const call: fn ([]const u8, ?*std.builtin.StackTrace, ?usize) noreturn = std.debug.defaultPanic; + +pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ + expected, found, + }); +} + +pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn { + @branchHint(.cold); + std.debug.panicExtra(ert, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)}); +} + +pub fn outOfBounds(index: usize, len: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len }); +} + +pub fn startGreaterThanEnd(start: usize, end: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end }); +} + +pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ + @tagName(accessed), @tagName(active), + }); +} + +pub const messages = std.debug.SimplePanic.messages; diff --git a/lib/std/debug/SimplePanic.zig b/lib/std/debug/SimplePanic.zig new file mode 100644 index 000000000000..b8e818c6fc5c --- /dev/null +++ b/lib/std/debug/SimplePanic.zig @@ -0,0 +1,86 @@ +//! This namespace is the default one used by the Zig compiler to emit various +//! kinds of safety panics, due to the logic in `std.builtin.Panic`. +//! +//! Since Zig does not have interfaces, this file serves as an example template +//! for users to provide their own alternative panic handling. +//! +//! As an alternative, see `std.debug.FormattedPanic`. + +const std = @import("../std.zig"); + +/// Prints the message to stderr without a newline and then traps. +/// +/// Explicit calls to `@panic` lower to calling this function. +pub fn call(msg: []const u8, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn { + @branchHint(.cold); + _ = ert; + _ = ra; + std.debug.lockStdErr(); + const stderr = std.io.getStdErr(); + stderr.writeAll(msg) catch {}; + @trap(); +} + +pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { + _ = found; + call("sentinel mismatch", null, null); +} + +pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn { + _ = ert; + _ = err; + call("attempt to unwrap error", null, null); +} + +pub fn outOfBounds(index: usize, len: usize) noreturn { + _ = index; + _ = len; + call("index out of bounds", null, null); +} + +pub fn startGreaterThanEnd(start: usize, end: usize) noreturn { + _ = start; + _ = end; + call("start index is larger than end index", null, null); +} + +pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { + _ = accessed; + call("access of inactive union field", null, null); +} + +pub const messages = struct { + pub const reached_unreachable = "reached unreachable code"; + pub const unwrap_null = "attempt to use null value"; + pub const cast_to_null = "cast causes pointer to be null"; + pub const incorrect_alignment = "incorrect alignment"; + pub const invalid_error_code = "invalid error code"; + pub const cast_truncated_data = "integer cast truncated bits"; + pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer"; + pub const integer_overflow = "integer overflow"; + pub const shl_overflow = "left shift overflowed bits"; + pub const shr_overflow = "right shift overflowed bits"; + pub const divide_by_zero = "division by zero"; + pub const exact_division_remainder = "exact division produced remainder"; + pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds"; + pub const corrupt_switch = "switch on corrupt value"; + pub const shift_rhs_too_big = "shift amount is greater than the type size"; + pub const invalid_enum_value = "invalid enum value"; + pub const for_len_mismatch = "for loop over objects with non-equal lengths"; + pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths"; + pub const memcpy_alias = "@memcpy arguments alias"; + pub const noreturn_returned = "'noreturn' function returned"; + + /// To be deleted after zig1.wasm is updated. + pub const inactive_union_field = "access of inactive union field"; + /// To be deleted after zig1.wasm is updated. + pub const sentinel_mismatch = "sentinel mismatch"; + /// To be deleted after zig1.wasm is updated. + pub const unwrap_error = "attempt to unwrap error"; + /// To be deleted after zig1.wasm is updated. + pub const index_out_of_bounds = "index out of bounds"; + /// To be deleted after zig1.wasm is updated. + pub const start_index_greater_than_end = "start index is larger than end index"; + /// To be deleted after zig1.wasm is updated. + pub const unreach = reached_unreachable; +}; diff --git a/src/Sema.zig b/src/Sema.zig index 0a66b04deb6f..8e36889f9287 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -2566,7 +2566,7 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Zcu.ErrorMsg std.debug.print("compile error during Sema:\n", .{}); var error_bundle = wip_errors.toOwnedBundle("") catch @panic("out of memory"); error_bundle.renderToStdErr(.{ .ttyconf = .no_color }); - crash_report.compilerPanic(.{ .explicit_call = "unexpected compile error occurred" }, null, null); + crash_report.compilerPanic("unexpected compile error occurred", null, null); } if (block) |start_block| { @@ -5810,6 +5810,8 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const src = block.nodeOffset(inst_data.src_node); const msg_inst = try sema.resolveInst(inst_data.operand); + // `panicWithMsg` would perform this coercion for us, but we can get a better + // source location if we do it here. const coerced_msg = try sema.coerce(block, Type.slice_const_u8, msg_inst, block.builtinCallArgSrc(inst_data.src_node, 0)); if (block.is_comptime) { @@ -5822,7 +5824,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void sema.branch_hint = .cold; } - try callPanic(sema, block, src, .explicit_call, coerced_msg, .@"@panic"); + try sema.panicWithMsg(block, src, coerced_msg, .@"@panic"); } fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -7303,33 +7305,6 @@ fn callBuiltin( ); } -const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?; - -fn callPanic( - sema: *Sema, - block: *Block, - call_src: LazySrcLoc, - tag: PanicCauseTag, - payload: Air.Inst.Ref, - call_operation: CallOperation, -) !void { - const pt = sema.pt; - const zcu = pt.zcu; - if (!zcu.backendSupportsFeature(.panic_fn)) { - _ = try block.addNoOp(.trap); - return; - } - const panic_cause_ty = try pt.getBuiltinType("PanicCause"); - const panic_cause = try unionInitFromEnumTag(sema, block, call_src, panic_cause_ty, @intFromEnum(tag), payload); - try preparePanic(sema, block, call_src); - const panic_fn = Air.internedToRef(zcu.panic_func_index); - const err_return_trace = try sema.getErrorReturnTrace(block); - const opt_usize_ty = try pt.optionalType(.usize_type); - const null_usize = try pt.nullValue(opt_usize_ty); - const args: [3]Air.Inst.Ref = .{ panic_cause, err_return_trace, Air.internedToRef(null_usize.toIntern()) }; - try sema.callBuiltin(block, call_src, panic_fn, .auto, &args, call_operation); -} - const CallOperation = enum { call, @"@call", @@ -14233,7 +14208,11 @@ fn maybeErrorUnwrap( .panic => { const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = try sema.resolveInst(inst_data.operand); - try callPanic(sema, block, operand_src, .explicit_call, msg_inst, .@"@panic"); + + const panic_fn = try pt.getBuiltinInnerType("Panic", "call"); + const err_return_trace = try sema.getErrorReturnTrace(block); + const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; + try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); return true; }, else => unreachable, @@ -17380,7 +17359,9 @@ fn analyzeArithmetic( if (block.wantSafety() and want_safety and scalar_tag == .int) { if (zcu.backendSupportsFeature(.safety_checked_instructions)) { - if (air_tag != air_tag_safe) try sema.preparePanicIntegerOverflow(block, src); + if (air_tag != air_tag_safe) { + _ = try sema.preparePanicId(block, src, .integer_overflow); + } return block.addBinOp(air_tag_safe, casted_lhs, casted_rhs); } else { const maybe_op_ov: ?Air.Inst.Tag = switch (air_tag) { @@ -21683,16 +21664,6 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const src = block.nodeOffset(inst_data.src_node); const operand = try sema.resolveInst(inst_data.operand); - return analyzeTagName(sema, block, src, operand_src, operand); -} - -fn analyzeTagName( - sema: *Sema, - block: *Block, - src: LazySrcLoc, - operand_src: LazySrcLoc, - operand: Air.Inst.Ref, -) CompileError!Air.Inst.Ref { const operand_ty = sema.typeOf(operand); const pt = sema.pt; const zcu = pt.zcu; @@ -27663,7 +27634,7 @@ fn explainWhyTypeIsNotPacked( } } -fn preparePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { +fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { const pt = sema.pt; const zcu = pt.zcu; @@ -27694,30 +27665,33 @@ fn preparePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { .val = .none, } }); } - - if (zcu.panic_cause_type == .none) { - const panic_cause_ty = try pt.getBuiltinType("PanicCause"); - try panic_cause_ty.resolveFields(pt); - zcu.panic_cause_type = panic_cause_ty.toIntern(); - zcu.panic_cause_tag_type = panic_cause_ty.unionTagType(zcu).?.toIntern(); - } } -fn preparePanicIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc) !void { +/// Backends depend on panic decls being available when lowering safety-checked +/// instructions. This function ensures the panic function will be available to +/// be called during that time. +fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) !InternPool.Nav.Index { const pt = sema.pt; const zcu = pt.zcu; - try preparePanic(sema, block, src); - if (zcu.panic_cause_integer_overflow == .none) { - const union_val = try pt.unionValue( - Type.fromInterned(zcu.panic_cause_type), - try pt.enumValueFieldIndex( - Type.fromInterned(zcu.panic_cause_tag_type), - @intFromEnum(PanicCauseTag.integer_overflow), - ), - Value.void, - ); - zcu.panic_cause_integer_overflow = try pt.refValue(union_val.toIntern()); - } + const gpa = sema.gpa; + if (zcu.panic_messages[@intFromEnum(panic_id)].unwrap()) |x| return x; + + try sema.prepareSimplePanic(block, src); + + const panic_messages_ty = try pt.getBuiltinType("panic_messages"); + const msg_nav_index = (sema.namespaceLookup( + block, + LazySrcLoc.unneeded, + panic_messages_ty.getNamespaceIndex(zcu), + try zcu.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls), + ) catch |err| switch (err) { + error.AnalysisFail => @panic("std.builtin.panic_messages is corrupt"), + error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable, + error.OutOfMemory => |e| return e, + }).?; + try sema.ensureNavResolved(src, msg_nav_index); + zcu.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional(); + return msg_nav_index; } fn addSafetyCheck( @@ -27725,7 +27699,7 @@ fn addSafetyCheck( parent_block: *Block, src: LazySrcLoc, ok: Air.Inst.Ref, - panic_cause_tag: PanicCauseTag, + panic_id: Zcu.PanicId, ) !void { const gpa = sema.gpa; assert(!parent_block.is_comptime); @@ -27743,7 +27717,7 @@ fn addSafetyCheck( defer fail_block.instructions.deinit(gpa); - try sema.safetyPanic(&fail_block, src, panic_cause_tag); + try sema.safetyPanic(&fail_block, src, panic_id); try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); } @@ -27812,6 +27786,29 @@ fn addSafetyCheckExtra( parent_block.instructions.appendAssumeCapacity(block_inst); } +fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.Ref, operation: CallOperation) !void { + const pt = sema.pt; + const zcu = pt.zcu; + + if (!zcu.backendSupportsFeature(.panic_fn)) { + _ = try block.addNoOp(.trap); + return; + } + + try sema.prepareSimplePanic(block, src); + + const panic_func = zcu.funcInfo(zcu.panic_func_index); + const panic_fn = try sema.analyzeNavVal(block, src, panic_func.owner_nav); + const null_stack_trace = Air.internedToRef(zcu.null_stack_trace); + + const opt_usize_ty = try pt.optionalType(.usize_type); + const null_ret_addr = Air.internedToRef((try pt.intern(.{ .opt = .{ + .ty = opt_usize_ty.toIntern(), + .val = .none, + } }))); + try sema.callBuiltin(block, src, panic_fn, .auto, &.{ msg_inst, null_stack_trace, null_ret_addr }, operation); +} + fn addSafetyCheckUnwrapError( sema: *Sema, parent_block: *Block, @@ -27849,7 +27846,7 @@ fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air. if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try block.addNoOp(.trap); } else { - const panic_fn = try pt.getBuiltin("panicUnwrapError"); + const panic_fn = try pt.getBuiltinInnerType("Panic", "unwrapError"); const err_return_trace = try sema.getErrorReturnTrace(block); const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; try sema.callBuiltin(block, src, panic_fn, .auto, &args, .@"safety check"); @@ -27866,7 +27863,7 @@ fn addSafetyCheckIndexOob( ) !void { assert(!parent_block.is_comptime); const ok = try parent_block.addBinOp(cmp_op, index, len); - return addSafetyCheckCall(sema, parent_block, src, ok, "panicOutOfBounds", &.{ index, len }); + return addSafetyCheckCall(sema, parent_block, src, ok, "outOfBounds", &.{ index, len }); } fn addSafetyCheckInactiveUnionField( @@ -27878,7 +27875,7 @@ fn addSafetyCheckInactiveUnionField( ) !void { assert(!parent_block.is_comptime); const ok = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag); - return addSafetyCheckCall(sema, parent_block, src, ok, "panicInactiveUnionField", &.{ active_tag, wanted_tag }); + return addSafetyCheckCall(sema, parent_block, src, ok, "inactiveUnionField", &.{ active_tag, wanted_tag }); } fn addSafetyCheckSentinelMismatch( @@ -27919,7 +27916,7 @@ fn addSafetyCheckSentinelMismatch( break :ok try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel); }; - return addSafetyCheckCall(sema, parent_block, src, ok, "panicSentinelMismatch", &.{ + return addSafetyCheckCall(sema, parent_block, src, ok, "sentinelMismatch", &.{ expected_sentinel, actual_sentinel, }); } @@ -27953,7 +27950,7 @@ fn addSafetyCheckCall( if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try fail_block.addNoOp(.trap); } else { - const panic_fn = try pt.getBuiltin(func_name); + const panic_fn = try pt.getBuiltinInnerType("Panic", func_name); try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); } @@ -27961,8 +27958,10 @@ fn addSafetyCheckCall( } /// This does not set `sema.branch_hint`. -fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_cause_tag: PanicCauseTag) CompileError!void { - try callPanic(sema, block, src, panic_cause_tag, .void_value, .@"safety check"); +fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) CompileError!void { + const msg_nav_index = try sema.preparePanicId(block, src, panic_id); + const msg_inst = try sema.analyzeNavVal(block, src, msg_nav_index); + try sema.panicWithMsg(block, src, msg_inst, .@"safety check"); } fn emitBackwardBranch(sema: *Sema, block: *Block, src: LazySrcLoc) !void { @@ -33456,7 +33455,7 @@ fn analyzeSlice( assert(!block.is_comptime); try sema.requireRuntimeBlock(block, src, runtime_src.?); const ok = try block.addBinOp(.cmp_lte, start, end); - try sema.addSafetyCheckCall(block, src, ok, "panicStartGreaterThanEnd", &.{ start, end }); + try sema.addSafetyCheckCall(block, src, ok, "startGreaterThanEnd", &.{ start, end }); } const new_len = if (by_length) try sema.coerce(block, Type.usize, uncasted_end_opt, end_src) diff --git a/src/Zcu.zig b/src/Zcu.zig index 34c074d3d48e..827c4cca84ee 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -210,17 +210,40 @@ all_type_references: std.ArrayListUnmanaged(TypeReference) = .empty, /// Freelist of indices in `all_type_references`. free_type_references: std.ArrayListUnmanaged(u32) = .empty, +panic_messages: [PanicId.len]InternPool.Nav.Index.Optional = .{.none} ** PanicId.len, /// The panic function body. panic_func_index: InternPool.Index = .none, null_stack_trace: InternPool.Index = .none, -panic_cause_type: InternPool.Index = .none, -panic_cause_tag_type: InternPool.Index = .none, -panic_cause_integer_overflow: InternPool.Index = .none, generation: u32 = 0, pub const PerThread = @import("Zcu/PerThread.zig"); +pub const PanicId = enum { + reached_unreachable, + unwrap_null, + cast_to_null, + incorrect_alignment, + invalid_error_code, + cast_truncated_data, + negative_to_unsigned, + integer_overflow, + shl_overflow, + shr_overflow, + divide_by_zero, + exact_division_remainder, + integer_part_out_of_bounds, + corrupt_switch, + shift_rhs_too_big, + invalid_enum_value, + for_len_mismatch, + memcpy_len_mismatch, + memcpy_alias, + noreturn_returned, + + pub const len = @typeInfo(PanicId).@"enum".fields.len; +}; + pub const GlobalErrorSet = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void); pub const CImportError = struct { diff --git a/src/crash_report.zig b/src/crash_report.zig index 6f0820b7825a..99264c840908 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -152,16 +152,12 @@ fn writeFilePath(file: *Zcu.File, writer: anytype) !void { try writer.writeAll(file.sub_file_path); } -pub fn compilerPanic( - cause: std.builtin.PanicCause, - error_return_trace: ?*std.builtin.StackTrace, - maybe_ret_addr: ?usize, -) noreturn { +pub fn compilerPanic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, maybe_ret_addr: ?usize) noreturn { @branchHint(.cold); PanicSwitch.preDispatch(); const ret_addr = maybe_ret_addr orelse @returnAddress(); const stack_ctx: StackContext = .{ .current = .{ .ret_addr = ret_addr } }; - PanicSwitch.dispatch(error_return_trace, stack_ctx, cause); + PanicSwitch.dispatch(error_return_trace, stack_ctx, msg); } /// Attaches a global SIGSEGV handler @@ -212,7 +208,7 @@ fn handleSegfaultPosix(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopa else => .not_supported, }; - PanicSwitch.dispatch(null, stack_ctx, .{ .explicit_call = error_msg }); + PanicSwitch.dispatch(null, stack_ctx, error_msg); } const WindowsSegfaultMessage = union(enum) { @@ -335,7 +331,7 @@ const PanicSwitch = struct { // it's happening and print a message. var panic_state: *volatile PanicState = &panic_state_raw; if (panic_state.awaiting_dispatch) { - dispatch(null, .{ .current = .{ .ret_addr = null } }, .{ .explicit_call = "Panic while preparing callstack" }); + dispatch(null, .{ .current = .{ .ret_addr = null } }, "Panic while preparing callstack"); } panic_state.awaiting_dispatch = true; } @@ -355,17 +351,17 @@ const PanicSwitch = struct { pub fn dispatch( trace: ?*const std.builtin.StackTrace, stack_ctx: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { var panic_state: *volatile PanicState = &panic_state_raw; debug.assert(panic_state.awaiting_dispatch); panic_state.awaiting_dispatch = false; nosuspend switch (panic_state.recover_stage) { - .initialize => goTo(initPanic, .{ panic_state, trace, stack_ctx, panic_cause }), - .report_stack => goTo(recoverReportStack, .{ panic_state, trace, stack_ctx, panic_cause }), - .release_mutex => goTo(recoverReleaseMutex, .{ panic_state, trace, stack_ctx, panic_cause }), - .release_ref_count => goTo(recoverReleaseRefCount, .{ panic_state, trace, stack_ctx, panic_cause }), - .abort => goTo(recoverAbort, .{ panic_state, trace, stack_ctx, panic_cause }), + .initialize => goTo(initPanic, .{ panic_state, trace, stack_ctx, msg }), + .report_stack => goTo(recoverReportStack, .{ panic_state, trace, stack_ctx, msg }), + .release_mutex => goTo(recoverReleaseMutex, .{ panic_state, trace, stack_ctx, msg }), + .release_ref_count => goTo(recoverReleaseRefCount, .{ panic_state, trace, stack_ctx, msg }), + .abort => goTo(recoverAbort, .{ panic_state, trace, stack_ctx, msg }), .silent_abort => goTo(abort, .{}), }; } @@ -374,7 +370,7 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { // use a temporary so there's only one volatile store const new_state = PanicState{ @@ -399,8 +395,6 @@ const PanicSwitch = struct { const current_thread_id = std.Thread.getCurrentId(); stderr.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state}); } - var buffer: [1000]u8 = undefined; - const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; stderr.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state}); state.recover_stage = .report_stack; @@ -416,9 +410,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { - recover(state, trace, stack, panic_cause); + recover(state, trace, stack, msg); state.recover_stage = .release_mutex; const stderr = io.getStdErr().writer(); @@ -441,9 +435,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { - recover(state, trace, stack, panic_cause); + recover(state, trace, stack, msg); goTo(releaseMutex, .{state}); } @@ -459,9 +453,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { - recover(state, trace, stack, panic_cause); + recover(state, trace, stack, msg); goTo(releaseRefCount, .{state}); } @@ -487,9 +481,9 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) noreturn { - recover(state, trace, stack, panic_cause); + recover(state, trace, stack, msg); state.recover_stage = .silent_abort; const stderr = io.getStdErr().writer(); @@ -513,9 +507,8 @@ const PanicSwitch = struct { state: *volatile PanicState, trace: ?*const std.builtin.StackTrace, stack: StackContext, - panic_cause: std.builtin.PanicCause, + msg: []const u8, ) void { - var buffer: [1000]u8 = undefined; switch (state.recover_verbosity) { .message_and_stack => { // lower the verbosity, and restore it at the end if we don't panic. @@ -523,7 +516,6 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked during a panic: ") catch {}; - const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; stderr.writeAll(msg) catch {}; stderr.writeAll("\nInner panic stack:\n") catch {}; if (trace) |t| { @@ -538,7 +530,6 @@ const PanicSwitch = struct { const stderr = io.getStdErr().writer(); stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {}; - const msg = buffer[0..std.debug.fmtPanicCause(&buffer, panic_cause)]; stderr.writeAll(msg) catch {}; stderr.writeAll("\n") catch {}; From 1b491e640d7c6a3cd71c4b146ca104ff0b136edd Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 15:22:57 -0700 Subject: [PATCH 13/21] fixes and make sema report errors when std.builtin wrong instead of panicking --- lib/std/builtin.zig | 2 +- src/Sema.zig | 121 ++++++++++++++++++++++++++++-------------- src/Zcu/PerThread.zig | 15 ------ src/codegen/llvm.zig | 22 ++++---- 4 files changed, 95 insertions(+), 65 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 5d3eca5f1e42..67a144eebfea 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -777,7 +777,7 @@ else /// root source file. pub const Panic: type = if (@hasDecl(root, "Panic")) root.Panic -else if (std.builtin.zig_backend == .stage2_riscv64) +else if (builtin.zig_backend == .stage2_riscv64) std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519 else std.debug.FormattedPanic; diff --git a/src/Sema.zig b/src/Sema.zig index 8e36889f9287..0f4c3bedbeb4 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -2141,7 +2141,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty)); // var st: StackTrace = undefined; - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty)); @@ -6945,7 +6945,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref if (!block.ownerModule().error_tracing) return .none; - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls); const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) { @@ -6987,7 +6987,7 @@ fn popErrorReturnTrace( // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or // the result is comptime-known to be a non-error. Either way, pop unconditionally. - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty); @@ -7013,7 +7013,7 @@ fn popErrorReturnTrace( defer then_block.instructions.deinit(gpa); // If non-error, then pop the error return trace by restoring the index. - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty); @@ -7156,7 +7156,7 @@ fn zirCall( // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only // need to clean-up our own trace if we were passed to a non-error-handling expression. if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) { - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "index", .no_embedded_nulls); const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src); @@ -10211,7 +10211,7 @@ fn finishFunc( if (!final_is_generic and sema.wantErrorReturnTracing(return_type)) { // Make sure that StackTrace's fields are resolved so that the backend can // lower this fn type. - const unresolved_stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace"); try unresolved_stack_trace_ty.resolveFields(pt); } @@ -14209,7 +14209,7 @@ fn maybeErrorUnwrap( const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = try sema.resolveInst(inst_data.operand); - const panic_fn = try pt.getBuiltinInnerType("Panic", "call"); + const panic_fn = try getBuiltinInnerAsInst(sema, block, operand_src, "Panic", "call"); const err_return_trace = try sema.getErrorReturnTrace(block); const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); @@ -18246,7 +18246,7 @@ fn zirBuiltinSrc( } }); }; - const src_loc_ty = try pt.getBuiltinType("SourceLocation"); + const src_loc_ty = try sema.getBuiltinType("SourceLocation"); const fields = .{ // module: [:0]const u8, module_name_val, @@ -18273,7 +18273,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ty = try sema.resolveType(block, src, inst_data.operand); - const type_info_ty = try pt.getBuiltinType("Type"); + const type_info_ty = try sema.getBuiltinType("Type"); const type_info_tag_ty = type_info_ty.unionTagType(zcu).?; if (ty.typeDeclInst(zcu)) |type_decl_inst| { @@ -18364,7 +18364,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai func_ty_info.return_type, } }); - const callconv_ty = try pt.getBuiltinType("CallingConvention"); + const callconv_ty = try sema.getBuiltinType("CallingConvention"); const field_values = .{ // calling_convention: CallingConvention, @@ -18389,7 +18389,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }, .int => { const int_info_ty = try getInnerType(sema, block, src, type_info_ty, "Int"); - const signedness_ty = try pt.getBuiltinType("Signedness"); + const signedness_ty = try sema.getBuiltinType("Signedness"); const info = ty.intInfo(zcu); const field_values = .{ // signedness: Signedness, @@ -18429,7 +18429,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai else try Type.fromInterned(info.child).lazyAbiAlignment(pt); - const addrspace_ty = try pt.getBuiltinType("AddressSpace"); + const addrspace_ty = try sema.getBuiltinType("AddressSpace"); const pointer_ty = try getInnerType(sema, block, src, type_info_ty, "Pointer"); const ptr_size_ty = try getInnerType(sema, block, src, pointer_ty, "Size"); @@ -20047,11 +20047,11 @@ fn retWithErrTracing( else => true, }; const gpa = sema.gpa; - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty); - const return_err_fn = try pt.getBuiltin("returnError"); + const return_err_fn = try sema.getBuiltin("returnError"); const args: [1]Air.Inst.Ref = .{err_return_trace}; if (!need_check) { @@ -21455,7 +21455,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern()); @@ -21744,7 +21744,7 @@ fn zirReify( }, }, }; - const type_info_ty = try pt.getBuiltinType("Type"); + const type_info_ty = try sema.getBuiltinType("Type"); const uncasted_operand = try sema.resolveInst(extra.operand); const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src); const val = try sema.resolveConstDefinedValue(block, operand_src, type_info, .{ @@ -22946,7 +22946,7 @@ fn reifyStruct( fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref { const pt = sema.pt; - const va_list_ty = try pt.getBuiltinType("VaList"); + const va_list_ty = try sema.getBuiltinType("VaList"); const va_list_ptr = try pt.singleMutPtrType(va_list_ty); const inst = try sema.resolveInst(zir_ref); @@ -22985,7 +22985,7 @@ fn zirCVaCopy(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) const va_list_src = block.builtinCallArgSrc(extra.node, 0); const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.operand); - const va_list_ty = try sema.pt.getBuiltinType("VaList"); + const va_list_ty = try sema.getBuiltinType("VaList"); try sema.requireRuntimeBlock(block, src, null); return block.addTyOp(.c_va_copy, va_list_ty, va_list_ref); @@ -23005,7 +23005,7 @@ fn zirCVaEnd(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref { const src = block.nodeOffset(@bitCast(extended.operand)); - const va_list_ty = try sema.pt.getBuiltinType("VaList"); + const va_list_ty = try sema.getBuiltinType("VaList"); try sema.requireRuntimeBlock(block, src, null); return block.addInst(.{ .tag = .c_va_start, @@ -24617,7 +24617,7 @@ fn resolveExportOptions( const zcu = pt.zcu; const gpa = sema.gpa; const ip = &zcu.intern_pool; - const export_options_ty = try pt.getBuiltinType("ExportOptions"); + const export_options_ty = try sema.getBuiltinType("ExportOptions"); const air_ref = try sema.resolveInst(zir_ref); const options = try sema.coerce(block, export_options_ty, air_ref, src); @@ -24681,7 +24681,7 @@ fn resolveBuiltinEnum( reason: NeededComptimeReason, ) CompileError!@field(std.builtin, name) { const pt = sema.pt; - const ty = try pt.getBuiltinType(name); + const ty = try sema.getBuiltinType(name); const air_ref = try sema.resolveInst(zir_ref); const coerced = try sema.coerce(block, ty, air_ref, src); const val = try sema.resolveConstDefinedValue(block, src, coerced, reason); @@ -25450,7 +25450,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data; const func = try sema.resolveInst(extra.callee); - const modifier_ty = try pt.getBuiltinType("CallModifier"); + const modifier_ty = try sema.getBuiltinType("CallModifier"); const air_ref = try sema.resolveInst(extra.modifier); const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src); const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{ @@ -26576,7 +26576,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const body = sema.code.bodySlice(extra_index, body_len); extra_index += body.len; - const addrspace_ty = try pt.getBuiltinType("AddressSpace"); + const addrspace_ty = try sema.getBuiltinType("AddressSpace"); const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{ .needed_comptime_reason = "addrspace must be comptime-known", }); @@ -26587,7 +26587,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A } else if (extra.data.bits.has_addrspace_ref) blk: { const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); extra_index += 1; - const addrspace_ty = try pt.getBuiltinType("AddressSpace"); + const addrspace_ty = try sema.getBuiltinType("AddressSpace"); const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) { error.GenericPoison => break :blk null, else => |e| return e, @@ -26641,7 +26641,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const body = sema.code.bodySlice(extra_index, body_len); extra_index += body.len; - const cc_ty = try pt.getBuiltinType("CallingConvention"); + const cc_ty = try sema.getBuiltinType("CallingConvention"); const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty, .{ .needed_comptime_reason = "calling convention must be comptime-known", }); @@ -26652,7 +26652,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A } else if (extra.data.bits.has_cc_ref) blk: { const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); extra_index += 1; - const cc_ty = try pt.getBuiltinType("CallingConvention"); + const cc_ty = try sema.getBuiltinType("CallingConvention"); const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) { error.GenericPoison => break :blk null, else => |e| return e, @@ -26869,7 +26869,7 @@ fn resolvePrefetchOptions( const zcu = pt.zcu; const gpa = sema.gpa; const ip = &zcu.intern_pool; - const options_ty = try pt.getBuiltinType("PrefetchOptions"); + const options_ty = try sema.getBuiltinType("PrefetchOptions"); const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src); const rw_src = block.src(.{ .init_field_rw = src.offset.node_offset_builtin_call_arg.builtin_call_node }); @@ -26942,7 +26942,7 @@ fn resolveExternOptions( const gpa = sema.gpa; const ip = &zcu.intern_pool; const options_inst = try sema.resolveInst(zir_ref); - const extern_options_ty = try pt.getBuiltinType("ExternOptions"); + const extern_options_ty = try sema.getBuiltinType("ExternOptions"); const options = try sema.coerce(block, extern_options_ty, options_inst, src); const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node }); @@ -27129,7 +27129,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr // Values are handled here. .calling_convention_c => { - const callconv_ty = try pt.getBuiltinType("CallingConvention"); + const callconv_ty = try sema.getBuiltinType("CallingConvention"); comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1); const val = try pt.intern(.{ .enum_tag = .{ .ty = callconv_ty.toIntern(), @@ -27138,7 +27138,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr return Air.internedToRef(val); }, .calling_convention_inline => { - const callconv_ty = try pt.getBuiltinType("CallingConvention"); + const callconv_ty = try sema.getBuiltinType("CallingConvention"); comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4); const val = try pt.intern(.{ .enum_tag = .{ .ty = callconv_ty.toIntern(), @@ -27147,7 +27147,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr return Air.internedToRef(val); }, }; - const ty = try pt.getBuiltinType(type_name); + const ty = try sema.getBuiltinType(type_name); return Air.internedToRef(ty.toIntern()); } @@ -27186,7 +27186,7 @@ fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat const uncoerced_hint = try sema.resolveInst(extra.operand); const operand_src = block.builtinCallArgSrc(extra.node, 0); - const hint_ty = try pt.getBuiltinType("BranchHint"); + const hint_ty = try sema.getBuiltinType("BranchHint"); const coerced_hint = try sema.coerce(block, hint_ty, uncoerced_hint, operand_src); const hint_val = try sema.resolveConstDefinedValue(block, operand_src, coerced_hint, .{ .needed_comptime_reason = "operand to '@branchHint' must be comptime-known", @@ -27650,7 +27650,7 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { } if (zcu.null_stack_trace == .none) { - const stack_trace_ty = try pt.getBuiltinType("StackTrace"); + const stack_trace_ty = try sema.getBuiltinType("StackTrace"); try stack_trace_ty.resolveFields(pt); const target = zcu.getTarget(); const ptr_stack_trace_ty = try pt.ptrTypeSema(.{ @@ -27678,7 +27678,7 @@ fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.Pan try sema.prepareSimplePanic(block, src); - const panic_messages_ty = try pt.getBuiltinType("panic_messages"); + const panic_messages_ty = try sema.getBuiltinType("panic_messages"); const msg_nav_index = (sema.namespaceLookup( block, LazySrcLoc.unneeded, @@ -27846,7 +27846,7 @@ fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air. if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try block.addNoOp(.trap); } else { - const panic_fn = try pt.getBuiltinInnerType("Panic", "unwrapError"); + const panic_fn = try getBuiltinInnerAsInst(sema, block, src, "Panic", "unwrapError"); const err_return_trace = try sema.getErrorReturnTrace(block); const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; try sema.callBuiltin(block, src, panic_fn, .auto, &args, .@"safety check"); @@ -27950,7 +27950,7 @@ fn addSafetyCheckCall( if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try fail_block.addNoOp(.trap); } else { - const panic_fn = try pt.getBuiltinInnerType("Panic", func_name); + const panic_fn = try getBuiltinInnerAsInst(sema, &fail_block, src, "Panic", func_name); try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); } @@ -35604,7 +35604,7 @@ pub fn resolveFnTypes(sema: *Sema, fn_ty: Type) CompileError!void { Type.fromInterned(fn_ty_info.return_type).isError(zcu)) { // Ensure the type exists so that backends can assume that. - _ = try pt.getBuiltinType("StackTrace"); + _ = try sema.getBuiltinType("StackTrace"); } for (0..fn_ty_info.param_types.len) |i| { @@ -37650,7 +37650,7 @@ pub fn analyzeAsAddressSpace( ) !std.builtin.AddressSpace { const pt = sema.pt; const zcu = pt.zcu; - const addrspace_ty = try pt.getBuiltinType("AddressSpace"); + const addrspace_ty = try sema.getBuiltinType("AddressSpace"); const coerced = try sema.coerce(block, addrspace_ty, air_ref, src); const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{ .needed_comptime_reason = "address space must be comptime-known", @@ -38908,6 +38908,19 @@ const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadR const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr; const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult; +/// Convenience function that looks 2 levels deep into `std.builtin`. +fn getBuiltinInnerAsInst( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + outer_name: []const u8, + inner_name: []const u8, +) !Air.Inst.Ref { + const outer_ty = try sema.getBuiltinType(outer_name); + const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name); + return Air.internedToRef(inner_val.toIntern()); +} + /// Convenience function that looks 2 levels deep into `std.builtin`. fn getBuiltinInnerType( sema: *Sema, @@ -38916,7 +38929,7 @@ fn getBuiltinInnerType( outer_name: []const u8, inner_name: []const u8, ) !Type { - const outer_ty = try sema.pt.getBuiltinType(outer_name); + const outer_ty = try sema.getBuiltinType(outer_name); return getInnerType(sema, block, src, outer_ty, inner_name); } @@ -38927,6 +38940,17 @@ fn getInnerType( outer_ty: Type, inner_name: []const u8, ) !Type { + const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name); + return inner_val.toType(); +} + +fn getInnerValue( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + outer_ty: Type, + inner_name: []const u8, +) !Value { const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; @@ -38938,5 +38962,22 @@ fn getInnerType( try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls), ) orelse return sema.fail(block, src, "std.builtin missing {s}", .{inner_name}); try sema.ensureNavResolved(src, nav); - return Type.fromInterned(ip.getNav(nav).status.resolved.val); + return Value.fromInterned(ip.getNav(nav).status.resolved.val); +} + +fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref { + const pt = sema.pt; + const zcu = pt.zcu; + const ip = &zcu.intern_pool; + const nav = try pt.getBuiltinNav(name); + try pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?); + return Air.internedToRef(ip.getNav(nav).status.resolved.val); +} + +fn getBuiltinType(sema: *Sema, name: []const u8) SemaError!Type { + const pt = sema.pt; + const ty_inst = try sema.getBuiltin(name); + const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt")); + try ty.resolveFully(pt); + return ty; } diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index 6ba7e2b707f5..13dd21fcd2a6 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -3075,14 +3075,6 @@ pub fn structPackedFieldBitOffset( unreachable; // index out of bounds } -pub fn getBuiltin(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Air.Inst.Ref { - const zcu = pt.zcu; - const ip = &zcu.intern_pool; - const nav = try pt.getBuiltinNav(name); - pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?) catch @panic("std.builtin is corrupt"); - return Air.internedToRef(ip.getNav(nav).status.resolved.val); -} - pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!InternPool.Nav.Index { const zcu = pt.zcu; const gpa = zcu.gpa; @@ -3100,13 +3092,6 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt"); } -pub fn getBuiltinType(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Type { - const ty_inst = try pt.getBuiltin(name); - const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt")); - ty.resolveFully(pt) catch @panic("std.builtin is corrupt"); - return ty; -} - pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.Error!Type { const zcu = pt.zcu; const ip = &zcu.intern_pool; diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 409ed742b43b..f4003347871c 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -5675,20 +5675,23 @@ pub const FuncGen = struct { } } - const PanicCauseTag = @typeInfo(std.builtin.PanicCause).@"union".tag_type.?; - - fn buildSimplePanic(fg: *FuncGen, panic_cause: InternPool.Index) !void { + fn buildSimplePanic(fg: *FuncGen, panic_id: Zcu.PanicId) !void { const o = fg.ng.object; const zcu = o.pt.zcu; const ip = &zcu.intern_pool; - const cause_ptr = try o.lowerValue(panic_cause); + const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?; + const msg_nav = ip.getNav(msg_nav_index); + const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu); + const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val); const null_opt_addr_global = try fg.resolveNullOptUsize(); const target = zcu.getTarget(); + const llvm_usize = try o.lowerType(Type.usize); // example: // call fastcc void @test2.panic( - // ptr @foo, ; panic_cause - // ptr null, ; stack trace - // ptr @2, ; addr (null ?usize) + // ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr + // i64 16, ; msg.len + // ptr null, ; stack trace + // ptr @2, ; addr (null ?usize) // ) const panic_func = zcu.funcInfo(zcu.panic_func_index); const panic_nav = ip.getNav(panic_func.owner_nav); @@ -5702,7 +5705,8 @@ pub const FuncGen = struct { panic_global.typeOf(&o.builder), panic_global.toValue(&o.builder), &.{ - cause_ptr.toValue(), + msg_ptr.toValue(), + try o.builder.intValue(llvm_usize, msg_len), try o.builder.nullValue(.ptr), null_opt_addr_global.toValue(), }, @@ -8331,7 +8335,7 @@ pub const FuncGen = struct { _ = try fg.wip.brCond(overflow_bit, fail_block, ok_block, .none); fg.wip.cursor = .{ .block = fail_block }; - try fg.buildSimplePanic(zcu.panic_cause_integer_overflow); + try fg.buildSimplePanic(.integer_overflow); fg.wip.cursor = .{ .block = ok_block }; return fg.wip.extractValue(results, &.{0}, ""); From db8c0744767b3d472f9682827a312a8ffed74adf Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 16:46:02 -0700 Subject: [PATCH 14/21] fix still calling std.builtin.panic sometimes --- lib/std/builtin.zig | 2 +- src/Sema.zig | 2 +- src/Zcu.zig | 5 +++-- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 67a144eebfea..664a45f12b86 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -770,7 +770,7 @@ pub const panic: PanicFn = if (@hasDecl(root, "panic")) else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) root.os.panic else - std.debug.defaultPanic; + Panic.call; /// This namespace is used by the Zig compiler to emit various kinds of safety /// panics. These can be overridden by making a public `Panic` namespace in the diff --git a/src/Sema.zig b/src/Sema.zig index 0f4c3bedbeb4..31da83f3440a 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -27639,7 +27639,7 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { const zcu = pt.zcu; if (zcu.panic_func_index == .none) { - const fn_ref = try sema.analyzeNavVal(block, src, try pt.getBuiltinNav("panic")); + const fn_ref = try sema.getBuiltinInnerAsInst(block, src, "Panic", "call"); const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{ .needed_comptime_reason = "panic handler must be comptime-known", }); diff --git a/src/Zcu.zig b/src/Zcu.zig index 827c4cca84ee..2a52bf4bcfd7 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -2918,8 +2918,9 @@ pub fn addGlobalAssembly(zcu: *Zcu, cau: InternPool.Cau.Index, source: []const u } pub const Feature = enum { - /// When this feature is enabled, Sema will emit calls to `std.builtin.panic` - /// for things like safety checks and unreachables. Otherwise traps will be emitted. + /// When this feature is enabled, Sema will emit calls to + /// `std.builtin.Panic` functions for things like safety checks and + /// unreachables. Otherwise traps will be emitted. panic_fn, /// When this feature is enabled, Sema will insert tracer functions for gathering a stack /// trace for error returns. From 7f4c0e010d1eaa47533a711c781783e808494083 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 17:14:17 -0700 Subject: [PATCH 15/21] update safety test cases to new panic API although they would also pass simply reverted to master branch because I made the deprecated API still work for now (to be removed after 0.14.0 is tagged) --- lib/std/builtin.zig | 23 +++++++++++++------ lib/std/debug/SimplePanic.zig | 2 +- .../panic_has_source_location.zig | 7 ++---- test/cases/safety/@alignCast misaligned.zig | 14 +++++++++-- .../@asyncCall with too small a frame.zig | 12 +++++++++- .../@enumFromInt - no matching tag value.zig | 14 +++++++++-- ...rCast error not present in destination.zig | 14 +++++++++-- ...ast error union casted to disjoint set.zig | 14 +++++++++-- test/cases/safety/@intCast to u0.zig | 14 +++++++++-- ...oat cannot fit - negative out of range.zig | 14 +++++++++-- ...loat cannot fit - negative to unsigned.zig | 14 +++++++++-- ...oat cannot fit - positive out of range.zig | 14 +++++++++-- ...o to non-optional byte-aligned pointer.zig | 14 +++++++++-- ...t address zero to non-optional pointer.zig | 14 +++++++++-- .../@ptrFromInt with misaligned address.zig | 14 +++++++++-- .../@tagName on corrupted enum value.zig | 14 +++++++++-- .../@tagName on corrupted union value.zig | 14 +++++++++-- .../array slice sentinel mismatch vector.zig | 14 +++++++++-- .../safety/array slice sentinel mismatch.zig | 21 ++++++++++------- test/cases/safety/bad union field access.zig | 23 +++++++++++-------- test/cases/safety/calling panic.zig | 21 ++++++++++------- ...ast []u8 to bigger slice of wrong size.zig | 14 +++++++++-- ...er to global error and no code matches.zig | 14 +++++++++-- ...mpty slice with sentinel out of bounds.zig | 21 ++++++++++------- .../exact division failure - vectors.zig | 14 +++++++++-- test/cases/safety/exact division failure.zig | 14 +++++++++-- test/cases/safety/for_len_mismatch.zig | 14 +++++++++-- test/cases/safety/for_len_mismatch_three.zig | 14 +++++++++-- .../ignored expression integer overflow.zig | 14 +++++++++-- .../safety/integer addition overflow.zig | 14 +++++++++-- .../integer division by zero - vectors.zig | 14 +++++++++-- .../cases/safety/integer division by zero.zig | 14 +++++++++-- .../integer multiplication overflow.zig | 14 +++++++++-- .../safety/integer negation overflow.zig | 14 +++++++++-- .../safety/integer subtraction overflow.zig | 14 +++++++++-- .../invalid resume of async function.zig | 12 +++++++++- test/cases/safety/memcpy_alias.zig | 14 +++++++++-- test/cases/safety/memcpy_len_mismatch.zig | 14 +++++++++-- .../safety/memset_array_undefined_bytes.zig | 14 +++++++++-- .../safety/memset_array_undefined_large.zig | 14 +++++++++-- .../safety/memset_slice_undefined_bytes.zig | 14 +++++++++-- .../safety/memset_slice_undefined_large.zig | 14 +++++++++-- test/cases/safety/modrem by zero.zig | 14 +++++++++-- test/cases/safety/modulus by zero.zig | 14 +++++++++-- test/cases/safety/noreturn returned.zig | 14 +++++++++-- ...suspend function call, callee suspends.zig | 12 +++++++++- .../optional unwrap operator on C pointer.zig | 14 +++++++++-- ...tional unwrap operator on null pointer.zig | 14 +++++++++-- .../out of bounds array slice by length.zig | 21 ++++++++++------- .../safety/out of bounds slice access.zig | 21 ++++++++++------- ...r casting null to non-optional pointer.zig | 14 +++++++++-- ...inter casting to null function pointer.zig | 14 +++++++++-- .../pointer slice sentinel mismatch.zig | 21 ++++++++++------- .../safety/remainder division by zero.zig | 14 +++++++++-- ...ng a function which is awaiting a call.zig | 12 +++++++++- ...g a function which is awaiting a frame.zig | 12 +++++++++- ...n which has been suspended and resumed.zig | 12 +++++++++- ...ed function which never been suspended.zig | 12 +++++++++- .../safety/shift left by huge amount.zig | 14 +++++++++-- .../safety/shift right by huge amount.zig | 14 +++++++++-- ...ed integer division overflow - vectors.zig | 14 +++++++++-- .../signed integer division overflow.zig | 14 +++++++++-- ...in cast to unsigned integer - widening.zig | 14 +++++++++-- ...ot fitting in cast to unsigned integer.zig | 14 +++++++++-- .../safety/signed shift left overflow.zig | 14 +++++++++-- .../safety/signed shift right overflow.zig | 14 +++++++++-- .../safety/signed-unsigned vector cast.zig | 14 +++++++++-- .../slice sentinel mismatch - floats.zig | 14 +++++++++-- ... sentinel mismatch - optional pointers.zig | 14 +++++++++-- .../safety/slice slice sentinel mismatch.zig | 21 ++++++++++------- ...ice start index greater than end index.zig | 21 ++++++++++------- ...h sentinel out of bounds - runtime len.zig | 21 ++++++++++------- .../slice with sentinel out of bounds.zig | 21 ++++++++++------- .../slicing null C pointer - runtime len.zig | 14 +++++++++-- test/cases/safety/slicing null C pointer.zig | 14 +++++++++-- ...else on corrupt enum value - one prong.zig | 14 +++++++++-- ...tch else on corrupt enum value - union.zig | 14 +++++++++-- .../switch else on corrupt enum value.zig | 14 +++++++++-- .../safety/switch on corrupted enum value.zig | 14 +++++++++-- .../switch on corrupted union value.zig | 14 +++++++++-- test/cases/safety/truncating vector cast.zig | 14 +++++++++-- test/cases/safety/unreachable.zig | 14 +++++++++-- ...ast to signed integer - same bit count.zig | 14 +++++++++-- .../safety/unsigned shift left overflow.zig | 14 +++++++++-- .../safety/unsigned shift right overflow.zig | 14 +++++++++-- .../safety/unsigned-signed vector cast.zig | 14 +++++++++-- test/cases/safety/unwrap error switch.zig | 21 ++++++++++------- test/cases/safety/unwrap error.zig | 21 ++++++++++------- ...e does not fit in shortening cast - u0.zig | 14 +++++++++-- .../value does not fit in shortening cast.zig | 14 +++++++++-- .../vector integer addition overflow.zig | 14 +++++++++-- ...vector integer multiplication overflow.zig | 14 +++++++++-- .../vector integer negation overflow.zig | 14 +++++++++-- .../vector integer subtraction overflow.zig | 14 +++++++++-- test/cases/safety/zero casted to error.zig | 14 +++++++++-- 95 files changed, 1129 insertions(+), 270 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 664a45f12b86..f2cd78160f9d 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -762,26 +762,35 @@ pub const TestFn = struct { }; /// Deprecated, use the `Panic` namespace instead. +/// To be deleted after 0.14.0 is released. pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn; - /// Deprecated, use the `Panic` namespace instead. -pub const panic: PanicFn = if (@hasDecl(root, "panic")) - root.panic -else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) - root.os.panic -else - Panic.call; +/// To be deleted after 0.14.0 is released. +pub const panic: PanicFn = Panic.call; /// This namespace is used by the Zig compiler to emit various kinds of safety /// panics. These can be overridden by making a public `Panic` namespace in the /// root source file. pub const Panic: type = if (@hasDecl(root, "Panic")) root.Panic +else if (@hasDecl(root, "panic")) // Deprecated, use `Panic` instead. + DeprecatedPanic else if (builtin.zig_backend == .stage2_riscv64) std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519 else std.debug.FormattedPanic; +/// To be deleted after 0.14.0 is released. +const DeprecatedPanic = struct { + pub const call = root.panic; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + /// To be deleted after zig1.wasm is updated. pub const panicSentinelMismatch = Panic.sentinelMismatch; /// To be deleted after zig1.wasm is updated. diff --git a/lib/std/debug/SimplePanic.zig b/lib/std/debug/SimplePanic.zig index b8e818c6fc5c..9685642a5c40 100644 --- a/lib/std/debug/SimplePanic.zig +++ b/lib/std/debug/SimplePanic.zig @@ -28,7 +28,7 @@ pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn { _ = ert; - _ = err; + _ = &err; call("attempt to unwrap error", null, null); } diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig index c29f126c9f76..6e9d16d76d24 100644 --- a/test/cases/compile_errors/panic_has_source_location.zig +++ b/test/cases/compile_errors/panic_has_source_location.zig @@ -6,10 +6,7 @@ export fn foo() void { @panic("oh no"); } -pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn { - _ = cause; - _ = ert; - _ = ra; +pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { @compileError("panic"); } @@ -17,4 +14,4 @@ pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ? // backend=stage2 // target=native // -// :13:5: error: panic +// :10:5: error: panic diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig index b514810730ca..393c3ae2f72f 100644 --- a/test/cases/safety/@alignCast misaligned.zig +++ b/test/cases/safety/@alignCast misaligned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .incorrect_alignment) { + if (std.mem.eql(u8, message, "incorrect alignment")) { std.process.exit(0); } std.process.exit(1); 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 3d7cdb3b1d02..47d29dc3e06d 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,17 @@ const std = @import("std"); const builtin = @import("builtin"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig index 10f526770294..067599c5da7c 100644 --- a/test/cases/safety/@enumFromInt - no matching tag value.zig +++ b/test/cases/safety/@enumFromInt - no matching tag value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig index 73b87ad20e65..0d92f9e18cb8 100644 --- a/test/cases/safety/@errorCast error not present in destination.zig +++ b/test/cases/safety/@errorCast error not present in destination.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig index bdb2d80760cd..6f9de8cf5f18 100644 --- a/test/cases/safety/@errorCast error union casted to disjoint set.zig +++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig index daf5069e61a8..d9bb489c70d8 100644 --- a/test/cases/safety/@intCast to u0.zig +++ b/test/cases/safety/@intCast to u0.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig index d029f9034302..fd7a91536623 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig index ea2365ea6dd1..0a7195bbc2f3 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig index 1bdc23982a17..395ee133c922 100644 --- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig index 2788a31fd915..963fdf70cbb1 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig index 81e450011573..6826343ff752 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig index 2c291f9ad355..ebf92b238dc5 100644 --- a/test/cases/safety/@ptrFromInt with misaligned address.zig +++ b/test/cases/safety/@ptrFromInt with misaligned address.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .incorrect_alignment) { + if (std.mem.eql(u8, message, "incorrect alignment")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig index a89dc72a9768..23ababf26470 100644 --- a/test/cases/safety/@tagName on corrupted enum value.zig +++ b/test/cases/safety/@tagName on corrupted enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig index 799a9c6a177f..38b86ef48291 100644 --- a/test/cases/safety/@tagName on corrupted union value.zig +++ b/test/cases/safety/@tagName on corrupted union value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig index aea05a6b4144..0185899c46bb 100644 --- a/test/cases/safety/array slice sentinel mismatch vector.zig +++ b/test/cases/safety/array slice sentinel mismatch vector.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig index 2e9bcf936614..f645e45f181a 100644 --- a/test/cases/safety/array slice sentinel mismatch.zig +++ b/test/cases/safety/array slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig index d73897f0f375..7258c37a44af 100644 --- a/test/cases/safety/bad union field access.zig +++ b/test/cases/safety/bad union field access.zig @@ -1,16 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .inactive_union_field => |info| { - if (std.mem.eql(u8, info.active, "int") and - std.mem.eql(u8, info.accessed, "float")) - { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig index d77f0dd91161..7a7c120b6b54 100644 --- a/test/cases/safety/calling panic.zig +++ b/test/cases/safety/calling panic.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .explicit_call => |message| { - if (std.mem.eql(u8, message, "oh no")) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "oh no")) { + std.process.exit(0); } std.process.exit(1); } 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 50dac0411c5a..9590482df1cb 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); 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 f6c5410a7b2a..aec6262275ef 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); 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 2c0a4ebb403a..aa72bb74dd33 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,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 1 and info.len == 0) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig index 8d65d833e134..2b0cf5f472c7 100644 --- a/test/cases/safety/exact division failure - vectors.zig +++ b/test/cases/safety/exact division failure - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig index 8fa31d6ee050..72179f312782 100644 --- a/test/cases/safety/exact division failure.zig +++ b/test/cases/safety/exact division failure.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig index 37a0761ee92e..17d43ab7f235 100644 --- a/test/cases/safety/for_len_mismatch.zig +++ b/test/cases/safety/for_len_mismatch.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .for_len_mismatch) { + if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig index 3f1f1ac23006..16faaab1f939 100644 --- a/test/cases/safety/for_len_mismatch_three.zig +++ b/test/cases/safety/for_len_mismatch_three.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .for_len_mismatch) { + if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig index 1ddb3588bccf..0552e47becb7 100644 --- a/test/cases/safety/ignored expression integer overflow.zig +++ b/test/cases/safety/ignored expression integer overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig index 8aea6c761624..0195a5436ee2 100644 --- a/test/cases/safety/integer addition overflow.zig +++ b/test/cases/safety/integer addition overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig index 3ac58efd313d..95dc075d6fbe 100644 --- a/test/cases/safety/integer division by zero - vectors.zig +++ b/test/cases/safety/integer division by zero - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig index 7f14acc9a4b8..c2b083c7bd91 100644 --- a/test/cases/safety/integer division by zero.zig +++ b/test/cases/safety/integer division by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig index d90d65ed86d6..1d194793a03a 100644 --- a/test/cases/safety/integer multiplication overflow.zig +++ b/test/cases/safety/integer multiplication overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig index 9a569b5338c8..b37819e33b25 100644 --- a/test/cases/safety/integer negation overflow.zig +++ b/test/cases/safety/integer negation overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig index a6591dd9ec42..e44eebade309 100644 --- a/test/cases/safety/integer subtraction overflow.zig +++ b/test/cases/safety/integer subtraction overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/invalid resume of async function.zig b/test/cases/safety/invalid resume of async function.zig index c58f13b99d05..834ed75ef44f 100644 --- a/test/cases/safety/invalid resume of async function.zig +++ b/test/cases/safety/invalid resume of async function.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig index 191a37f8eb77..a01a597d901e 100644 --- a/test/cases/safety/memcpy_alias.zig +++ b/test/cases/safety/memcpy_alias.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .memcpy_alias) { + if (std.mem.eql(u8, message, "@memcpy arguments alias")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig index aa5bb92732e8..943ddb582ce6 100644 --- a/test/cases/safety/memcpy_len_mismatch.zig +++ b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .memcpy_len_mismatch) { + if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig index c1c86df1aa54..4347ba55e514 100644 --- a/test/cases/safety/memset_array_undefined_bytes.zig +++ b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig index 3cab2f4c5fce..efbff0e9ce91 100644 --- a/test/cases/safety/memset_array_undefined_large.zig +++ b/test/cases/safety/memset_array_undefined_large.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig index d6a7e3e5cd95..08401efd591b 100644 --- a/test/cases/safety/memset_slice_undefined_bytes.zig +++ b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig index a5e572eefdbe..3f3131098243 100644 --- a/test/cases/safety/memset_slice_undefined_large.zig +++ b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig index 16616f4801f9..11949fb89667 100644 --- a/test/cases/safety/modrem by zero.zig +++ b/test/cases/safety/modrem by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig index 454b1cd43218..9ddd96c4585b 100644 --- a/test/cases/safety/modulus by zero.zig +++ b/test/cases/safety/modulus by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig index ac413089e77e..a6cf3e91ee5f 100644 --- a/test/cases/safety/noreturn returned.zig +++ b/test/cases/safety/noreturn returned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .noreturn_returned) { + if (std.mem.eql(u8, message, "'noreturn' function returned")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/nosuspend function call, callee suspends.zig b/test/cases/safety/nosuspend function call, callee suspends.zig index 50f457f31458..f40dfc14b05a 100644 --- a/test/cases/safety/nosuspend function call, callee suspends.zig +++ b/test/cases/safety/nosuspend function call, callee suspends.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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 59ffe381a483..da67bca3b9b0 100644 --- a/test/cases/safety/optional unwrap operator on C pointer.zig +++ b/test/cases/safety/optional unwrap operator on C pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); 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 9b09d63f7bbb..3992f75ff3f5 100644 --- a/test/cases/safety/optional unwrap operator on null pointer.zig +++ b/test/cases/safety/optional unwrap operator on null pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig index 9ad18972f849..3aef3eb425ce 100644 --- a/test/cases/safety/out of bounds array slice by length.zig +++ b/test/cases/safety/out of bounds array slice by length.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 16 and info.len == 5) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig index 7b7ac0f8fa26..474be34db7be 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out of bounds slice access.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 4 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) { + std.process.exit(0); } std.process.exit(1); } 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 ad8921ae92df..8f5715647109 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig index 364f66ab1924..13404b1a48ae 100644 --- a/test/cases/safety/pointer casting to null function pointer.zig +++ b/test/cases/safety/pointer casting to null function pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig index 7d79144fcf8a..a7a9eb94b670 100644 --- a/test/cases/safety/pointer slice sentinel mismatch.zig +++ b/test/cases/safety/pointer slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig index 9fee0aa13ac5..8681970a4ba7 100644 --- a/test/cases/safety/remainder division by zero.zig +++ b/test/cases/safety/remainder division by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); 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 47545584eaf1..0e101594be8d 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,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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 26df1ae900b4..d005e31cd8da 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,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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 f8bf6d44c08f..931d4de3e089 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,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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 af288ab8ba39..fb7d97b8ffe2 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,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +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 09425b2cc1d2..01b40e0bfc35 100644 --- a/test/cases/safety/shift left by huge amount.zig +++ b/test/cases/safety/shift left by huge amount.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shift_rhs_too_big) { + if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig index b02e2a01af27..7ef33ddb36a5 100644 --- a/test/cases/safety/shift right by huge amount.zig +++ b/test/cases/safety/shift right by huge amount.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shift_rhs_too_big) { + if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig index 0da140b8f2de..623e1eac2174 100644 --- a/test/cases/safety/signed integer division overflow - vectors.zig +++ b/test/cases/safety/signed integer division overflow - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig index 576e3ef7aa50..df805db4d944 100644 --- a/test/cases/safety/signed integer division overflow.zig +++ b/test/cases/safety/signed integer division overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); 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 762719df8165..a446cde23a62 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); 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 765a50d5a562..b839b36a2247 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig index 148d79ca4d61..5f9cb3aaceef 100644 --- a/test/cases/safety/signed shift left overflow.zig +++ b/test/cases/safety/signed shift left overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shl_overflow) { + if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig index f89f57a132a6..c65a361da5ee 100644 --- a/test/cases/safety/signed shift right overflow.zig +++ b/test/cases/safety/signed shift right overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shr_overflow) { + if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig index 2dee04d1bfa8..34f540ddb038 100644 --- a/test/cases/safety/signed-unsigned vector cast.zig +++ b/test/cases/safety/signed-unsigned vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig index 71b32e0c8a50..11ce2ff321c5 100644 --- a/test/cases/safety/slice sentinel mismatch - floats.zig +++ b/test/cases/safety/slice sentinel mismatch - floats.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig index 5e69a1d35032..6e0766dfbe77 100644 --- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig +++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig index 7f90b9edbfa4..58f80bd11be2 100644 --- a/test/cases/safety/slice slice sentinel mismatch.zig +++ b/test/cases/safety/slice slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig index 5cdf1e46e947..55589c86847c 100644 --- a/test/cases/safety/slice start index greater than end index.zig +++ b/test/cases/safety/slice start index greater than end index.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .start_index_greater_than_end => |info| { - if (info.start == 10 and info.end == 1) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { + std.process.exit(0); } std.process.exit(1); } 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 09d8fa32a579..80afb81f60c0 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,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 5 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { + std.process.exit(0); } std.process.exit(1); } 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 1ec069865767..d36cb7141ab4 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice with sentinel out of bounds.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 5 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { + std.process.exit(0); } std.process.exit(1); } 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 d4ebbdff18fd..7886121378a9 100644 --- a/test/cases/safety/slicing null C pointer - runtime len.zig +++ b/test/cases/safety/slicing null C pointer - runtime len.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig index b3e50b0ebf1e..502c7a1bbbbd 100644 --- a/test/cases/safety/slicing null C pointer.zig +++ b/test/cases/safety/slicing null C pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig index bc8321a34693..7e1e8dfce205 100644 --- a/test/cases/safety/switch else on corrupt enum value - one prong.zig +++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig index 4f6e00c85a0a..b6781682d7b5 100644 --- a/test/cases/safety/switch else on corrupt enum value - union.zig +++ b/test/cases/safety/switch else on corrupt enum value - union.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig index 1d3821739920..b06dec9168bc 100644 --- a/test/cases/safety/switch else on corrupt enum value.zig +++ b/test/cases/safety/switch else on corrupt enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig index 159140180881..23f288432906 100644 --- a/test/cases/safety/switch on corrupted enum value.zig +++ b/test/cases/safety/switch on corrupted enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig index 1ae72fcbfbf3..1829d3104f9f 100644 --- a/test/cases/safety/switch on corrupted union value.zig +++ b/test/cases/safety/switch on corrupted union value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig index 32fb40755597..e68b029c3332 100644 --- a/test/cases/safety/truncating vector cast.zig +++ b/test/cases/safety/truncating vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig index b12b1a722f88..bb55a01cfe71 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .reached_unreachable) { + if (std.mem.eql(u8, message, "reached unreachable code")) { std.process.exit(0); } std.process.exit(1); 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 937d52256915..399e66c21691 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig index 53fe91c9fb98..b7d1ffe09b64 100644 --- a/test/cases/safety/unsigned shift left overflow.zig +++ b/test/cases/safety/unsigned shift left overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shl_overflow) { + if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig index a5389797fc3b..aa5fbf493caf 100644 --- a/test/cases/safety/unsigned shift right overflow.zig +++ b/test/cases/safety/unsigned shift right overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shr_overflow) { + if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig index aab2f5ae168a..1599eb045f64 100644 --- a/test/cases/safety/unsigned-signed vector cast.zig +++ b/test/cases/safety/unsigned-signed vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig index dd587c48653c..9661efddddec 100644 --- a/test/cases/safety/unwrap error switch.zig +++ b/test/cases/safety/unwrap error switch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .unwrap_error => |err| { - if (err == error.Whatever) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig index a2ac8f50461c..f42847246244 100644 --- a/test/cases/safety/unwrap error.zig +++ b/test/cases/safety/unwrap error.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .unwrap_error => |err| { - if (err == error.Whatever) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { + std.process.exit(0); } std.process.exit(1); } 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 d06d1cf440d4..e6a4d84135f5 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); 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 3f55f40f963e..f2eaf3fd6e24 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,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig index 3e3145db862d..8cb936b2c7b5 100644 --- a/test/cases/safety/vector integer addition overflow.zig +++ b/test/cases/safety/vector integer addition overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig index eceb507efa16..d3ae414bf62d 100644 --- a/test/cases/safety/vector integer multiplication overflow.zig +++ b/test/cases/safety/vector integer multiplication overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig index 5f408dab8b6d..3c84df786a92 100644 --- a/test/cases/safety/vector integer negation overflow.zig +++ b/test/cases/safety/vector integer negation overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig index c858ac5e341f..dd34dd11e7d9 100644 --- a/test/cases/safety/vector integer subtraction overflow.zig +++ b/test/cases/safety/vector integer subtraction overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig index 591e4b62ef9e..83f93622ce39 100644 --- a/test/cases/safety/zero casted to error.zig +++ b/test/cases/safety/zero casted to error.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); From 37d1da5beda9857611fd3120c5e9b0d7cbba546e Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 20:24:46 -0700 Subject: [PATCH 16/21] I think it's better to put the imports at the top --- src/Zcu/PerThread.zig | 52 +++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index 13dd21fcd2a6..8cc72dc4d933 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -1,6 +1,32 @@ //! This type provides a wrapper around a `*Zcu` for uses which require a thread `Id`. //! Any operation which mutates `InternPool` state lives here rather than on `Zcu`. +const Air = @import("../Air.zig"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const Ast = std.zig.Ast; +const AstGen = std.zig.AstGen; +const BigIntConst = std.math.big.int.Const; +const BigIntMutable = std.math.big.int.Mutable; +const build_options = @import("build_options"); +const builtin = @import("builtin"); +const Cache = std.Build.Cache; +const dev = @import("../dev.zig"); +const InternPool = @import("../InternPool.zig"); +const AnalUnit = InternPool.AnalUnit; +const isUpDir = @import("../introspect.zig").isUpDir; +const Liveness = @import("../Liveness.zig"); +const log = std.log.scoped(.zcu); +const Module = @import("../Package.zig").Module; +const Sema = @import("../Sema.zig"); +const std = @import("std"); +const target_util = @import("../target.zig"); +const trace = @import("../tracy.zig").trace; +const Type = @import("../Type.zig"); +const Value = @import("../Value.zig"); +const Zcu = @import("../Zcu.zig"); +const Zir = std.zig.Zir; + zcu: *Zcu, /// Dense, per-thread unique index. @@ -3659,29 +3685,3 @@ pub fn refValue(pt: Zcu.PerThread, val: InternPool.Index) Zcu.SemaError!InternPo .byte_offset = 0, } }); } - -const Air = @import("../Air.zig"); -const Allocator = std.mem.Allocator; -const assert = std.debug.assert; -const Ast = std.zig.Ast; -const AstGen = std.zig.AstGen; -const BigIntConst = std.math.big.int.Const; -const BigIntMutable = std.math.big.int.Mutable; -const build_options = @import("build_options"); -const builtin = @import("builtin"); -const Cache = std.Build.Cache; -const dev = @import("../dev.zig"); -const InternPool = @import("../InternPool.zig"); -const AnalUnit = InternPool.AnalUnit; -const isUpDir = @import("../introspect.zig").isUpDir; -const Liveness = @import("../Liveness.zig"); -const log = std.log.scoped(.zcu); -const Module = @import("../Package.zig").Module; -const Sema = @import("../Sema.zig"); -const std = @import("std"); -const target_util = @import("../target.zig"); -const trace = @import("../tracy.zig").trace; -const Type = @import("../Type.zig"); -const Value = @import("../Value.zig"); -const Zcu = @import("../Zcu.zig"); -const Zir = std.zig.Zir; From 5b1a9fbb45128fdab615d7af5e93fa037e5d7749 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 20:25:09 -0700 Subject: [PATCH 17/21] update crash report to the new panic interface --- src/crash_report.zig | 14 +++++++++++++- src/main.zig | 3 +-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/src/crash_report.zig b/src/crash_report.zig index 99264c840908..d9f8bac35074 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -13,11 +13,23 @@ const Sema = @import("Sema.zig"); const InternPool = @import("InternPool.zig"); const Zir = std.zig.Zir; const Decl = Zcu.Decl; +const dev = @import("dev.zig"); /// To use these crash report diagnostics, publish this panic in your main file /// and add `pub const enable_segfault_handler = false;` to your `std_options`. /// You will also need to call initialize() on startup, preferably as the very first operation in your program. -pub const panic = if (build_options.enable_debug_extensions) compilerPanic else std.debug.defaultPanic; +pub const Panic = if (build_options.enable_debug_extensions) struct { + pub const call = compilerPanic; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +} else if (dev.env == .bootstrap) + std.debug.SimplePanic +else + std.debug.FormattedPanic; /// Install signal handlers to identify crashes and report diagnostics. pub fn initialize() void { diff --git a/src/main.zig b/src/main.zig index b08acf568c62..684217c36c7c 100644 --- a/src/main.zig +++ b/src/main.zig @@ -44,8 +44,7 @@ pub const std_options = .{ }, }; -// Crash report needs to override the panic handler -pub const panic = crash_report.panic; +pub const Panic = crash_report.Panic; var wasi_preopens: fs.wasi.Preopens = undefined; pub fn wasi_cwd() std.os.wasi.fd_t { From 2e14cbe9cd4a5a17fcdfcfa79869feef718f3076 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 20:53:26 -0700 Subject: [PATCH 18/21] Sema: better utility function semantics better names, return error instead of panicking, better diagnostics, use the standard APIs for resolving values --- src/Sema.zig | 152 ++++++++++++++++++++++++--------------------------- 1 file changed, 71 insertions(+), 81 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 31da83f3440a..ea409be6ab37 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -14209,10 +14209,10 @@ fn maybeErrorUnwrap( const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = try sema.resolveInst(inst_data.operand); - const panic_fn = try getBuiltinInnerAsInst(sema, block, operand_src, "Panic", "call"); + const panic_fn = try getPanicInnerFn(sema, block, operand_src, "call"); const err_return_trace = try sema.getErrorReturnTrace(block); const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; - try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); + try sema.callBuiltin(block, operand_src, Air.internedToRef(panic_fn), .auto, &args, .@"safety check"); return true; }, else => unreachable, @@ -18293,8 +18293,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai => |type_info_tag| return unionInitFromEnumTag(sema, block, src, type_info_ty, @intFromEnum(type_info_tag), .void_value), .@"fn" => { - const fn_info_ty = try getInnerType(sema, block, src, type_info_ty, "Fn"); - const param_info_ty = try getInnerType(sema, block, src, fn_info_ty, "Param"); + const fn_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Fn"); + const param_info_ty = try getBuiltinInnerType(sema, block, src, fn_info_ty, "Type.Fn", "Param"); const func_ty_info = zcu.typeToFunc(ty).?; const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); @@ -18388,7 +18388,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .int => { - const int_info_ty = try getInnerType(sema, block, src, type_info_ty, "Int"); + const int_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Int"); const signedness_ty = try sema.getBuiltinType("Signedness"); const info = ty.intInfo(zcu); const field_values = .{ @@ -18407,7 +18407,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .float => { - const float_info_ty = try getInnerType(sema, block, src, type_info_ty, "Float"); + const float_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Float"); const field_vals = .{ // bits: u16, @@ -18430,8 +18430,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai try Type.fromInterned(info.child).lazyAbiAlignment(pt); const addrspace_ty = try sema.getBuiltinType("AddressSpace"); - const pointer_ty = try getInnerType(sema, block, src, type_info_ty, "Pointer"); - const ptr_size_ty = try getInnerType(sema, block, src, pointer_ty, "Size"); + const pointer_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Pointer"); + const ptr_size_ty = try getBuiltinInnerType(sema, block, src, pointer_ty, "Type.Pointer", "Size"); const field_values = .{ // size: Size, @@ -18464,7 +18464,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .array => { - const array_field_ty = try getInnerType(sema, block, src, type_info_ty, "Array"); + const array_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Array"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -18485,7 +18485,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .vector => { - const vector_field_ty = try getInnerType(sema, block, src, type_info_ty, "Vector"); + const vector_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Vector"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -18504,7 +18504,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .optional => { - const optional_field_ty = try getInnerType(sema, block, src, type_info_ty, "Optional"); + const optional_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Optional"); const field_values = .{ // child: type, @@ -18521,7 +18521,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }, .error_set => { // Get the Error type - const error_field_ty = try getInnerType(sema, block, src, type_info_ty, "Error"); + const error_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Error"); // Build our list of Error values // Optional value is only null if anyerror @@ -18617,7 +18617,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .error_union => { - const error_union_field_ty = try getInnerType(sema, block, src, type_info_ty, "ErrorUnion"); + const error_union_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ErrorUnion"); const field_values = .{ // error_set: type, @@ -18637,7 +18637,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .@"enum" => { const is_exhaustive = Value.makeBool(ip.loadEnumType(ty.toIntern()).tag_mode != .nonexhaustive); - const enum_field_ty = try getInnerType(sema, block, src, type_info_ty, "EnumField"); + const enum_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "EnumField"); const enum_field_vals = try sema.arena.alloc(InternPool.Index, ip.loadEnumType(ty.toIntern()).names.len); for (enum_field_vals, 0..) |*field_val, tag_index| { @@ -18724,7 +18724,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.loadEnumType(ty.toIntern()).namespace.toOptional()); - const type_enum_ty = try getInnerType(sema, block, src, type_info_ty, "Enum"); + const type_enum_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Enum"); const field_values = .{ // tag_type: type, @@ -18746,8 +18746,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .@"union" => { - const type_union_ty = try getInnerType(sema, block, src, type_info_ty, "Union"); - const union_field_ty = try getInnerType(sema, block, src, type_info_ty, "UnionField"); + const type_union_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Union"); + const union_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "UnionField"); try ty.resolveLayout(pt); // Getting alignment requires type layout const union_obj = zcu.typeToUnion(ty).?; @@ -18842,7 +18842,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .val = if (ty.unionTagType(zcu)) |tag_ty| tag_ty.toIntern() else .none, } }); - const container_layout_ty = try getBuiltinInnerType(sema, block, src, "Type", "ContainerLayout"); + const container_layout_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ContainerLayout"); const field_values = .{ // layout: ContainerLayout, @@ -18865,8 +18865,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .@"struct" => { - const type_struct_ty = try getInnerType(sema, block, src, type_info_ty, "Struct"); - const struct_field_ty = try getInnerType(sema, block, src, type_info_ty, "StructField"); + const type_struct_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Struct"); + const struct_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "StructField"); try ty.resolveLayout(pt); // Getting alignment requires type layout @@ -19043,7 +19043,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } else .none, } }); - const container_layout_ty = try getInnerType(sema, block, src, type_info_ty, "ContainerLayout"); + const container_layout_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ContainerLayout"); const layout = ty.containerLayout(zcu); @@ -19069,7 +19069,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }))); }, .@"opaque" => { - const type_opaque_ty = try getInnerType(sema, block, src, type_info_ty, "Opaque"); + const type_opaque_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Opaque"); try ty.resolveFields(pt); const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(zcu)); @@ -19103,7 +19103,7 @@ fn typeInfoDecls( const zcu = pt.zcu; const gpa = sema.gpa; - const declaration_ty = try getInnerType(sema, block, src, type_info_ty, "Declaration"); + const declaration_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Declaration"); var decl_vals = std.ArrayList(InternPool.Index).init(gpa); defer decl_vals.deinit(); @@ -27639,14 +27639,10 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void { const zcu = pt.zcu; if (zcu.panic_func_index == .none) { - const fn_ref = try sema.getBuiltinInnerAsInst(block, src, "Panic", "call"); - const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{ - .needed_comptime_reason = "panic handler must be comptime-known", - }); - assert(fn_val.typeOf(zcu).zigTypeTag(zcu) == .@"fn"); - assert(try fn_val.typeOf(zcu).fnHasRuntimeBitsSema(pt)); - try zcu.ensureFuncBodyAnalysisQueued(fn_val.toIntern()); - zcu.panic_func_index = fn_val.toIntern(); + zcu.panic_func_index = try sema.getPanicInnerFn(block, src, "call"); + // Here, function body analysis must be queued up so that backends can + // make calls to this function. + try zcu.ensureFuncBodyAnalysisQueued(zcu.panic_func_index); } if (zcu.null_stack_trace == .none) { @@ -27678,14 +27674,15 @@ fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.Pan try sema.prepareSimplePanic(block, src); - const panic_messages_ty = try sema.getBuiltinType("panic_messages"); + const panic_ty = try sema.getBuiltinType("Panic"); + const panic_messages_ty = try sema.getBuiltinInnerType(block, src, panic_ty, "Panic", "messages"); const msg_nav_index = (sema.namespaceLookup( block, LazySrcLoc.unneeded, panic_messages_ty.getNamespaceIndex(zcu), try zcu.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls), ) catch |err| switch (err) { - error.AnalysisFail => @panic("std.builtin.panic_messages is corrupt"), + error.AnalysisFail => return error.AnalysisFail, error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable, error.OutOfMemory => |e| return e, }).?; @@ -27846,10 +27843,10 @@ fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air. if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try block.addNoOp(.trap); } else { - const panic_fn = try getBuiltinInnerAsInst(sema, block, src, "Panic", "unwrapError"); + const panic_fn = try getPanicInnerFn(sema, block, src, "unwrapError"); const err_return_trace = try sema.getErrorReturnTrace(block); const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; - try sema.callBuiltin(block, src, panic_fn, .auto, &args, .@"safety check"); + try sema.callBuiltin(block, src, Air.internedToRef(panic_fn), .auto, &args, .@"safety check"); } } @@ -27950,8 +27947,8 @@ fn addSafetyCheckCall( if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try fail_block.addNoOp(.trap); } else { - const panic_fn = try getBuiltinInnerAsInst(sema, &fail_block, src, "Panic", func_name); - try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); + const panic_fn = try getPanicInnerFn(sema, &fail_block, src, func_name); + try sema.callBuiltin(&fail_block, src, Air.internedToRef(panic_fn), .auto, args, .@"safety check"); } try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); @@ -38908,61 +38905,62 @@ const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadR const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr; const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult; -/// Convenience function that looks 2 levels deep into `std.builtin`. -fn getBuiltinInnerAsInst( +fn getPanicInnerFn( sema: *Sema, block: *Block, src: LazySrcLoc, - outer_name: []const u8, inner_name: []const u8, -) !Air.Inst.Ref { - const outer_ty = try sema.getBuiltinType(outer_name); - const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name); - return Air.internedToRef(inner_val.toIntern()); +) !InternPool.Index { + const gpa = sema.gpa; + const pt = sema.pt; + const zcu = pt.zcu; + const ip = &zcu.intern_pool; + const outer_ty = try sema.getBuiltinType("Panic"); + const inner_name_ip = try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls); + const opt_fn_ref = try namespaceLookupVal(sema, block, src, outer_ty.getNamespaceIndex(zcu), inner_name_ip); + const fn_ref = opt_fn_ref orelse return sema.fail(block, src, "std.builtin.Panic missing {s}", .{inner_name}); + const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{ + .needed_comptime_reason = "panic handler must be comptime-known", + }); + if (fn_val.typeOf(zcu).zigTypeTag(zcu) != .@"fn") { + return sema.fail(block, src, "std.builtin.Panic.{s} is not a function", .{inner_name}); + } + // Better not to queue up function body analysis because the function might be generic, and + // the semantic analysis for the call will already queue if necessary. + return fn_val.toIntern(); } -/// Convenience function that looks 2 levels deep into `std.builtin`. -fn getBuiltinInnerType( - sema: *Sema, - block: *Block, - src: LazySrcLoc, - outer_name: []const u8, - inner_name: []const u8, -) !Type { - const outer_ty = try sema.getBuiltinType(outer_name); - return getInnerType(sema, block, src, outer_ty, inner_name); +fn getBuiltinType(sema: *Sema, name: []const u8) SemaError!Type { + const pt = sema.pt; + const ty_inst = try sema.getBuiltin(name); + const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt")); + try ty.resolveFully(pt); + return ty; } -fn getInnerType( +fn getBuiltinInnerType( sema: *Sema, block: *Block, src: LazySrcLoc, outer_ty: Type, + /// Relative to "std.builtin". + compile_error_parent_name: []const u8, inner_name: []const u8, ) !Type { - const inner_val = try getInnerValue(sema, block, src, outer_ty, inner_name); - return inner_val.toType(); -} - -fn getInnerValue( - sema: *Sema, - block: *Block, - src: LazySrcLoc, - outer_ty: Type, - inner_name: []const u8, -) !Value { const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; const gpa = sema.gpa; - const nav = try sema.namespaceLookup( - block, - src, - outer_ty.getNamespaceIndex(zcu), - try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls), - ) orelse return sema.fail(block, src, "std.builtin missing {s}", .{inner_name}); + const inner_name_ip = try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls); + const opt_nav = try sema.namespaceLookup(block, src, outer_ty.getNamespaceIndex(zcu), inner_name_ip); + const nav = opt_nav orelse return sema.fail(block, src, "std.builtin.{s} missing {s}", .{ + compile_error_parent_name, inner_name, + }); try sema.ensureNavResolved(src, nav); - return Value.fromInterned(ip.getNav(nav).status.resolved.val); + const val = Value.fromInterned(ip.getNav(nav).status.resolved.val); + const ty = val.toType(); + try ty.resolveFully(pt); + return ty; } fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref { @@ -38973,11 +38971,3 @@ fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref { try pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?); return Air.internedToRef(ip.getNav(nav).status.resolved.val); } - -fn getBuiltinType(sema: *Sema, name: []const u8) SemaError!Type { - const pt = sema.pt; - const ty_inst = try sema.getBuiltin(name); - const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt")); - try ty.resolveFully(pt); - return ty; -} From 737b58168180d62822155f20514f5188c80912d6 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 20:57:21 -0700 Subject: [PATCH 19/21] disable plan9 test This experimental target has no recent active maintainer. It's the only linker backend complaining about this branch and I can't make sense of the stack trace. This can be fixed asynchronously by anyone who wants to maintain plan9 support. It does not need to block this branch. --- test/cases/exit.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cases/exit.zig b/test/cases/exit.zig index 23d17afe1120..a1c256802ca0 100644 --- a/test/cases/exit.zig +++ b/test/cases/exit.zig @@ -1,5 +1,5 @@ pub fn main() void {} // run -// target=x86_64-linux,x86_64-macos,x86_64-windows,x86_64-plan9 +// target=x86_64-linux,x86_64-macos,x86_64-windows // From 777e722b0618afc524aa83cea89526b18413c7a6 Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Fri, 27 Sep 2024 12:23:34 +0200 Subject: [PATCH 20/21] macho: increase pre-allocated vmsize for __TEXT_ZIG segment --- src/link/MachO.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 42923ecfba20..13a33b4cfa6c 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -3230,7 +3230,7 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void { self.zig_text_seg_index = try self.addSegment("__TEXT_ZIG", .{ .fileoff = off, .filesize = filesize, - .vmaddr = base_vmaddr + 0x8000000, + .vmaddr = base_vmaddr + 0x4000000, .vmsize = filesize, .prot = macho.PROT.READ | macho.PROT.EXEC, }); From 2857ca1edc1c3fa83298d2e8f6d505a3776f1ae3 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 28 Sep 2024 12:16:41 -0700 Subject: [PATCH 21/21] revert safety test cases to rely on deprecated old API in case someone wants to pursue the idea of making the panic interface a struct, this will reduce churn. --- test/cases/safety/@alignCast misaligned.zig | 12 +----------- .../safety/@asyncCall with too small a frame.zig | 12 +----------- .../safety/@enumFromInt - no matching tag value.zig | 12 +----------- .../@errorCast error not present in destination.zig | 12 +----------- ...@errorCast error union casted to disjoint set.zig | 12 +----------- test/cases/safety/@intCast to u0.zig | 12 +----------- ...tFromFloat cannot fit - negative out of range.zig | 12 +----------- ...ntFromFloat cannot fit - negative to unsigned.zig | 12 +----------- ...tFromFloat cannot fit - positive out of range.zig | 12 +----------- ...ess zero to non-optional byte-aligned pointer.zig | 12 +----------- ...rFromInt address zero to non-optional pointer.zig | 12 +----------- .../safety/@ptrFromInt with misaligned address.zig | 12 +----------- .../safety/@tagName on corrupted enum value.zig | 12 +----------- .../safety/@tagName on corrupted union value.zig | 12 +----------- .../safety/array slice sentinel mismatch vector.zig | 12 +----------- test/cases/safety/array slice sentinel mismatch.zig | 12 +----------- test/cases/safety/bad union field access.zig | 12 +----------- test/cases/safety/calling panic.zig | 12 +----------- .../cast []u8 to bigger slice of wrong size.zig | 12 +----------- ...t integer to global error and no code matches.zig | 12 +----------- .../empty slice with sentinel out of bounds.zig | 12 +----------- .../safety/exact division failure - vectors.zig | 12 +----------- test/cases/safety/exact division failure.zig | 12 +----------- test/cases/safety/for_len_mismatch.zig | 12 +----------- test/cases/safety/for_len_mismatch_three.zig | 12 +----------- .../safety/ignored expression integer overflow.zig | 12 +----------- test/cases/safety/integer addition overflow.zig | 12 +----------- .../safety/integer division by zero - vectors.zig | 12 +----------- test/cases/safety/integer division by zero.zig | 12 +----------- .../cases/safety/integer multiplication overflow.zig | 12 +----------- test/cases/safety/integer negation overflow.zig | 12 +----------- test/cases/safety/integer subtraction overflow.zig | 12 +----------- .../safety/invalid resume of async function.zig | 12 +----------- test/cases/safety/memcpy_alias.zig | 12 +----------- test/cases/safety/memcpy_len_mismatch.zig | 12 +----------- test/cases/safety/memset_array_undefined_bytes.zig | 12 +----------- test/cases/safety/memset_array_undefined_large.zig | 12 +----------- test/cases/safety/memset_slice_undefined_bytes.zig | 12 +----------- test/cases/safety/memset_slice_undefined_large.zig | 12 +----------- test/cases/safety/modrem by zero.zig | 12 +----------- test/cases/safety/modulus by zero.zig | 12 +----------- test/cases/safety/noreturn returned.zig | 12 +----------- .../nosuspend function call, callee suspends.zig | 12 +----------- .../safety/optional unwrap operator on C pointer.zig | 12 +----------- .../optional unwrap operator on null pointer.zig | 12 +----------- .../safety/out of bounds array slice by length.zig | 12 +----------- test/cases/safety/out of bounds slice access.zig | 12 +----------- .../pointer casting null to non-optional pointer.zig | 12 +----------- .../pointer casting to null function pointer.zig | 12 +----------- .../cases/safety/pointer slice sentinel mismatch.zig | 12 +----------- test/cases/safety/remainder division by zero.zig | 12 +----------- .../resuming a function which is awaiting a call.zig | 12 +----------- ...resuming a function which is awaiting a frame.zig | 12 +----------- ...function which has been suspended and resumed.zig | 12 +----------- ...suspended function which never been suspended.zig | 12 +----------- test/cases/safety/shift left by huge amount.zig | 12 +----------- test/cases/safety/shift right by huge amount.zig | 12 +----------- .../signed integer division overflow - vectors.zig | 12 +----------- .../safety/signed integer division overflow.zig | 12 +----------- ...itting in cast to unsigned integer - widening.zig | 12 +----------- ...teger not fitting in cast to unsigned integer.zig | 12 +----------- test/cases/safety/signed shift left overflow.zig | 12 +----------- test/cases/safety/signed shift right overflow.zig | 12 +----------- test/cases/safety/signed-unsigned vector cast.zig | 12 +----------- .../safety/slice sentinel mismatch - floats.zig | 12 +----------- .../slice sentinel mismatch - optional pointers.zig | 12 +----------- test/cases/safety/slice slice sentinel mismatch.zig | 12 +----------- .../slice start index greater than end index.zig | 12 +----------- ...ice with sentinel out of bounds - runtime len.zig | 12 +----------- .../safety/slice with sentinel out of bounds.zig | 12 +----------- .../safety/slicing null C pointer - runtime len.zig | 12 +----------- test/cases/safety/slicing null C pointer.zig | 12 +----------- ...switch else on corrupt enum value - one prong.zig | 12 +----------- .../switch else on corrupt enum value - union.zig | 12 +----------- .../safety/switch else on corrupt enum value.zig | 12 +----------- test/cases/safety/switch on corrupted enum value.zig | 12 +----------- .../cases/safety/switch on corrupted union value.zig | 12 +----------- test/cases/safety/truncating vector cast.zig | 12 +----------- test/cases/safety/unreachable.zig | 12 +----------- ...ng in cast to signed integer - same bit count.zig | 12 +----------- test/cases/safety/unsigned shift left overflow.zig | 12 +----------- test/cases/safety/unsigned shift right overflow.zig | 12 +----------- test/cases/safety/unsigned-signed vector cast.zig | 12 +----------- test/cases/safety/unwrap error switch.zig | 12 +----------- test/cases/safety/unwrap error.zig | 12 +----------- .../value does not fit in shortening cast - u0.zig | 12 +----------- .../safety/value does not fit in shortening cast.zig | 12 +----------- .../safety/vector integer addition overflow.zig | 12 +----------- .../vector integer multiplication overflow.zig | 12 +----------- .../safety/vector integer negation overflow.zig | 12 +----------- .../safety/vector integer subtraction overflow.zig | 12 +----------- test/cases/safety/zero casted to error.zig | 12 +----------- 92 files changed, 92 insertions(+), 1012 deletions(-) diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig index 393c3ae2f72f..ade27c2747a8 100644 --- a/test/cases/safety/@alignCast misaligned.zig +++ b/test/cases/safety/@alignCast misaligned.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 47d29dc3e06d..3d7cdb3b1d02 100644 --- a/test/cases/safety/@asyncCall with too small a frame.zig +++ b/test/cases/safety/@asyncCall with too small a frame.zig @@ -1,17 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig index 067599c5da7c..5051869cc0cb 100644 --- a/test/cases/safety/@enumFromInt - no matching tag value.zig +++ b/test/cases/safety/@enumFromInt - no matching tag value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig index 0d92f9e18cb8..ff86e1f78382 100644 --- a/test/cases/safety/@errorCast error not present in destination.zig +++ b/test/cases/safety/@errorCast error not present in destination.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig index 6f9de8cf5f18..c9da2fc636ae 100644 --- a/test/cases/safety/@errorCast error union casted to disjoint set.zig +++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig index d9bb489c70d8..a33da87f0fa8 100644 --- a/test/cases/safety/@intCast to u0.zig +++ b/test/cases/safety/@intCast to u0.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig index fd7a91536623..a5a8d831b337 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig index 0a7195bbc2f3..1bf1a667659f 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig index 395ee133c922..15a9fa7ad188 100644 --- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig index 963fdf70cbb1..f8c448855e34 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig index 6826343ff752..c9ae253df7ba 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig index ebf92b238dc5..3952ab9baa2f 100644 --- a/test/cases/safety/@ptrFromInt with misaligned address.zig +++ b/test/cases/safety/@ptrFromInt with misaligned address.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig index 23ababf26470..e23cd1fcf692 100644 --- a/test/cases/safety/@tagName on corrupted enum value.zig +++ b/test/cases/safety/@tagName on corrupted enum value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 38b86ef48291..09d8276d2339 100644 --- a/test/cases/safety/@tagName on corrupted union value.zig +++ b/test/cases/safety/@tagName on corrupted union value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig index 0185899c46bb..da20d988691f 100644 --- a/test/cases/safety/array slice sentinel mismatch vector.zig +++ b/test/cases/safety/array slice sentinel mismatch vector.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 f645e45f181a..fc196186732d 100644 --- a/test/cases/safety/array slice sentinel mismatch.zig +++ b/test/cases/safety/array slice sentinel mismatch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/bad union field access.zig b/test/cases/safety/bad union field access.zig index 7258c37a44af..c6706d41764d 100644 --- a/test/cases/safety/bad union field access.zig +++ b/test/cases/safety/bad union field access.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { std.process.exit(0); diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig index 7a7c120b6b54..832bc5f19ad2 100644 --- a/test/cases/safety/calling panic.zig +++ b/test/cases/safety/calling panic.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 9590482df1cb..a72b2fcca2ca 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 aec6262275ef..61daf07a2ba2 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 aa72bb74dd33..69201fde307c 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig index 2b0cf5f472c7..c5df2b276f17 100644 --- a/test/cases/safety/exact division failure - vectors.zig +++ b/test/cases/safety/exact division failure - vectors.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 72179f312782..cdf1b1fb8d31 100644 --- a/test/cases/safety/exact division failure.zig +++ b/test/cases/safety/exact division failure.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig index 17d43ab7f235..ee21b947d7ee 100644 --- a/test/cases/safety/for_len_mismatch.zig +++ b/test/cases/safety/for_len_mismatch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig index 16faaab1f939..70f854def51f 100644 --- a/test/cases/safety/for_len_mismatch_three.zig +++ b/test/cases/safety/for_len_mismatch_three.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig index 0552e47becb7..f8e3f0bf0aa6 100644 --- a/test/cases/safety/ignored expression integer overflow.zig +++ b/test/cases/safety/ignored expression integer overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 addition overflow.zig b/test/cases/safety/integer addition overflow.zig index 0195a5436ee2..4f7c5b2cb3f5 100644 --- a/test/cases/safety/integer addition overflow.zig +++ b/test/cases/safety/integer addition overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 95dc075d6fbe..6e2af616b909 100644 --- a/test/cases/safety/integer division by zero - vectors.zig +++ b/test/cases/safety/integer division by zero - vectors.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 c2b083c7bd91..0d1b79d26d8f 100644 --- a/test/cases/safety/integer division by zero.zig +++ b/test/cases/safety/integer division by zero.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 1d194793a03a..641801277dbd 100644 --- a/test/cases/safety/integer multiplication overflow.zig +++ b/test/cases/safety/integer multiplication overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 b37819e33b25..3d4c134c4a68 100644 --- a/test/cases/safety/integer negation overflow.zig +++ b/test/cases/safety/integer negation overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 e44eebade309..84a16f55b870 100644 --- a/test/cases/safety/integer subtraction overflow.zig +++ b/test/cases/safety/integer subtraction overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 834ed75ef44f..c58f13b99d05 100644 --- a/test/cases/safety/invalid resume of async function.zig +++ b/test/cases/safety/invalid resume of async function.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig index a01a597d901e..d87a7bf6aa4d 100644 --- a/test/cases/safety/memcpy_alias.zig +++ b/test/cases/safety/memcpy_alias.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "@memcpy arguments alias")) { std.process.exit(0); diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig index 943ddb582ce6..6ca36abccbbf 100644 --- a/test/cases/safety/memcpy_len_mismatch.zig +++ b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig index 4347ba55e514..e0ce2dac0443 100644 --- a/test/cases/safety/memset_array_undefined_bytes.zig +++ b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig index efbff0e9ce91..dbc1cf442024 100644 --- a/test/cases/safety/memset_array_undefined_large.zig +++ b/test/cases/safety/memset_array_undefined_large.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig index 08401efd591b..4214b5db4b76 100644 --- a/test/cases/safety/memset_slice_undefined_bytes.zig +++ b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig index 3f3131098243..d1f4f651d33b 100644 --- a/test/cases/safety/memset_slice_undefined_large.zig +++ b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/modrem by zero.zig b/test/cases/safety/modrem by zero.zig index 11949fb89667..f201062c0e8f 100644 --- a/test/cases/safety/modrem by zero.zig +++ b/test/cases/safety/modrem by zero.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 9ddd96c4585b..6714458979d0 100644 --- a/test/cases/safety/modulus by zero.zig +++ b/test/cases/safety/modulus by zero.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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/noreturn returned.zig b/test/cases/safety/noreturn returned.zig index a6cf3e91ee5f..c3c30af37ee4 100644 --- a/test/cases/safety/noreturn returned.zig +++ b/test/cases/safety/noreturn returned.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "'noreturn' function returned")) { 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 f40dfc14b05a..50f457f31458 100644 --- a/test/cases/safety/nosuspend function call, callee suspends.zig +++ b/test/cases/safety/nosuspend function call, callee suspends.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 da67bca3b9b0..bd3313265a50 100644 --- a/test/cases/safety/optional unwrap operator on C pointer.zig +++ b/test/cases/safety/optional unwrap operator on C pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 3992f75ff3f5..9dda4d0a9e07 100644 --- a/test/cases/safety/optional unwrap operator on null pointer.zig +++ b/test/cases/safety/optional unwrap operator on null pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig index 3aef3eb425ce..62768abebf60 100644 --- a/test/cases/safety/out of bounds array slice by length.zig +++ b/test/cases/safety/out of bounds array slice by length.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 16, len 5")) { 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 474be34db7be..b4c87948a5ce 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out of bounds slice access.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 8f5715647109..fdf8dc17ce27 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig index 13404b1a48ae..8f399b66dc27 100644 --- a/test/cases/safety/pointer casting to null function pointer.zig +++ b/test/cases/safety/pointer casting to null function pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 a7a9eb94b670..3972528edf42 100644 --- a/test/cases/safety/pointer slice sentinel mismatch.zig +++ b/test/cases/safety/pointer slice sentinel mismatch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 8681970a4ba7..3dc97f6e16fd 100644 --- a/test/cases/safety/remainder division by zero.zig +++ b/test/cases/safety/remainder division by zero.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 0e101594be8d..47545584eaf1 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 d005e31cd8da..26df1ae900b4 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 931d4de3e089..f8bf6d44c08f 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 fb7d97b8ffe2..af288ab8ba39 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 01b40e0bfc35..a038c0ee4442 100644 --- a/test/cases/safety/shift left by huge amount.zig +++ b/test/cases/safety/shift left by huge amount.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 7ef33ddb36a5..ced81d948d48 100644 --- a/test/cases/safety/shift right by huge amount.zig +++ b/test/cases/safety/shift right by huge amount.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 623e1eac2174..6346d9f1a1dd 100644 --- a/test/cases/safety/signed integer division overflow - vectors.zig +++ b/test/cases/safety/signed integer division overflow - vectors.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 df805db4d944..9d1014ceec08 100644 --- a/test/cases/safety/signed integer division overflow.zig +++ b/test/cases/safety/signed integer division overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 a446cde23a62..87c812eddc20 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 b839b36a2247..5d8c3f88c8a3 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 5f9cb3aaceef..f9a4db81ce92 100644 --- a/test/cases/safety/signed shift left overflow.zig +++ b/test/cases/safety/signed shift left overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 c65a361da5ee..7d71b9ffbde3 100644 --- a/test/cases/safety/signed shift right overflow.zig +++ b/test/cases/safety/signed shift right overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 34f540ddb038..2e3b4d25d52d 100644 --- a/test/cases/safety/signed-unsigned vector cast.zig +++ b/test/cases/safety/signed-unsigned vector cast.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 11ce2ff321c5..19b9b86c3ba8 100644 --- a/test/cases/safety/slice sentinel mismatch - floats.zig +++ b/test/cases/safety/slice sentinel mismatch - floats.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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.2e0, found 4e0")) { 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 6e0766dfbe77..a3b4a98575e6 100644 --- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig +++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 58f80bd11be2..635706b2c58a 100644 --- a/test/cases/safety/slice slice sentinel mismatch.zig +++ b/test/cases/safety/slice slice sentinel mismatch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig index 55589c86847c..83d489ab5699 100644 --- a/test/cases/safety/slice start index greater than end index.zig +++ b/test/cases/safety/slice start index greater than end index.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { 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 80afb81f60c0..abb3cc42f092 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 d36cb7141ab4..1683dc9d3f32 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice with sentinel out of bounds.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 7886121378a9..dd73a5011205 100644 --- a/test/cases/safety/slicing null C pointer - runtime len.zig +++ b/test/cases/safety/slicing null C pointer - runtime len.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 502c7a1bbbbd..862f2dcfdba6 100644 --- a/test/cases/safety/slicing null C pointer.zig +++ b/test/cases/safety/slicing null C pointer.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig index 7e1e8dfce205..c11227c3bee8 100644 --- a/test/cases/safety/switch else on corrupt enum value - one prong.zig +++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig index b6781682d7b5..a63c78597e66 100644 --- a/test/cases/safety/switch else on corrupt enum value - union.zig +++ b/test/cases/safety/switch else on corrupt enum value - union.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig index b06dec9168bc..7e050838c086 100644 --- a/test/cases/safety/switch else on corrupt enum value.zig +++ b/test/cases/safety/switch else on corrupt enum value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 enum value.zig b/test/cases/safety/switch on corrupted enum value.zig index 23f288432906..f89076191172 100644 --- a/test/cases/safety/switch on corrupted enum value.zig +++ b/test/cases/safety/switch on corrupted enum value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 1829d3104f9f..fc93c9d6e7f0 100644 --- a/test/cases/safety/switch on corrupted union value.zig +++ b/test/cases/safety/switch on corrupted union value.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 e68b029c3332..ae76d4dec125 100644 --- a/test/cases/safety/truncating vector cast.zig +++ b/test/cases/safety/truncating vector cast.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 bb55a01cfe71..492f7958b18b 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 399e66c21691..9bd4c4200702 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 b7d1ffe09b64..d38d8f6ecf06 100644 --- a/test/cases/safety/unsigned shift left overflow.zig +++ b/test/cases/safety/unsigned shift left overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 aa5fbf493caf..121797a17d4c 100644 --- a/test/cases/safety/unsigned shift right overflow.zig +++ b/test/cases/safety/unsigned shift right overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 1599eb045f64..32676f7c1cb6 100644 --- a/test/cases/safety/unsigned-signed vector cast.zig +++ b/test/cases/safety/unsigned-signed vector cast.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 9661efddddec..0723a9fb246a 100644 --- a/test/cases/safety/unwrap error switch.zig +++ b/test/cases/safety/unwrap error switch.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 f42847246244..e2d7ea725b8b 100644 --- a/test/cases/safety/unwrap error.zig +++ b/test/cases/safety/unwrap error.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 e6a4d84135f5..ec111a2caedd 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 f2eaf3fd6e24..a5ea41659e86 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,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 8cb936b2c7b5..21c26eeb4e47 100644 --- a/test/cases/safety/vector integer addition overflow.zig +++ b/test/cases/safety/vector integer addition overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 d3ae414bf62d..8678eccec6fe 100644 --- a/test/cases/safety/vector integer multiplication overflow.zig +++ b/test/cases/safety/vector integer multiplication overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 3c84df786a92..5f8becad177c 100644 --- a/test/cases/safety/vector integer negation overflow.zig +++ b/test/cases/safety/vector integer negation overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 dd34dd11e7d9..82c034212104 100644 --- a/test/cases/safety/vector integer subtraction overflow.zig +++ b/test/cases/safety/vector integer subtraction overflow.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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 83f93622ce39..78340db3163c 100644 --- a/test/cases/safety/zero casted to error.zig +++ b/test/cases/safety/zero casted to error.zig @@ -1,16 +1,6 @@ const std = @import("std"); -pub const Panic = struct { - pub const call = panic; - pub const unwrapError = std.debug.FormattedPanic.unwrapError; - pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; - pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; - pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; - pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; - pub const messages = std.debug.FormattedPanic.messages; -}; - -fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) 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);