Undefined Behavior

Zig has many instances of undefined behavior. If undefined behavior is detected at compile-time, Zig emits a compile error and refuses to continue. Most undefined behavior that cannot be detected at compile-time can be detected at runtime. In these cases, Zig has safety checks. Safety checks can be disabled on a per-block basis with @setRuntimeSafety. The ReleaseFast and ReleaseSmall build modes disable all safety checks (except where overridden by @setRuntimeSafety) in order to facilitate optimizations.

When a safety check fails, Zig crashes with a stack trace, like this:

test.zig

  1. test "safety check" {
  2. unreachable;
  3. }

Shell

  1. $ zig test test.zig
  2. 1/1 test.safety check... thread 3584529 panic: reached unreachable code
  3. docgen_tmp/test.zig:2:5: 0x211565 in test.safety check (test)
  4. unreachable;
  5. ^
  6. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/test_runner.zig:63:28: 0x212cf3 in main (test)
  7. } else test_fn.func();
  8. ^
  9. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x211e7c in posixCallMainAndExit (test)
  10. root.main();
  11. ^
  12. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x211981 in _start (test)
  13. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  14. ^
  15. error: the following test command crashed:
  16. /home/ci/release-0.10.1/out/zig-local-cache/o/886dbde2c2a21074c6c6d3ff9b83336b/test

Reaching Unreachable Code

At compile-time:

test.zig

  1. comptime {
  2. assert(false);
  3. }
  4. fn assert(ok: bool) void {
  5. if (!ok) unreachable; // assertion failure
  6. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:5:14: error: reached unreachable code
  3. if (!ok) unreachable; // assertion failure
  4. ^~~~~~~~~~~
  5. docgen_tmp/test.zig:2:11: note: called from here
  6. assert(false);
  7. ~~~~~~^~~~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. std.debug.assert(false);
  4. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3584625 panic: reached unreachable code
  4. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/debug.zig:278:14: 0x211a0c in assert (test)
  5. if (!ok) unreachable; // assertion failure
  6. ^
  7. docgen_tmp/test.zig:4:21: 0x21015a in main (test)
  8. std.debug.assert(false);
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f6ec in posixCallMainAndExit (test)
  11. root.main();
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f1f1 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

Index out of Bounds

At compile-time:

test.zig

  1. comptime {
  2. const array: [5]u8 = "hello".*;
  3. const garbage = array[5];
  4. _ = garbage;
  5. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:27: error: index 5 outside array of length 5
  3. const garbage = array[5];
  4. ^

At runtime:

test.zig

  1. pub fn main() void {
  2. var x = foo("hello");
  3. _ = x;
  4. }
  5. fn foo(x: []const u8) u8 {
  6. return x[5];
  7. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3584735 panic: index out of bounds: index 5, len 5
  4. docgen_tmp/test.zig:7:13: 0x211cea in foo (test)
  5. return x[5];
  6. ^
  7. docgen_tmp/test.zig:2:16: 0x21016b in main (test)
  8. var x = foo("hello");
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f6ec in posixCallMainAndExit (test)
  11. root.main();
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f1f1 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

Cast Negative Number to Unsigned Integer

At compile-time:

test.zig

  1. comptime {
  2. var value: i32 = -1;
  3. const unsigned = @intCast(u32, value);
  4. _ = unsigned;
  5. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:36: error: type 'u32' cannot represent integer value '-1'
  3. const unsigned = @intCast(u32, value);
  4. ^~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var value: i32 = -1;
  4. var unsigned = @intCast(u32, value);
  5. std.debug.print("value: {}\n", .{unsigned});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3584859 panic: attempt to cast negative value to unsigned integer
  4. docgen_tmp/test.zig:5:20: 0x21036d in main (test)
  5. var unsigned = @intCast(u32, value);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f8cc in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f3d1 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

To obtain the maximum value of an unsigned integer, use std.math.maxInt.

Cast Truncates Data

At compile-time:

test.zig

  1. comptime {
  2. const spartan_count: u16 = 300;
  3. const byte = @intCast(u8, spartan_count);
  4. _ = byte;
  5. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:31: error: type 'u8' cannot represent integer value '300'
  3. const byte = @intCast(u8, spartan_count);
  4. ^~~~~~~~~~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var spartan_count: u16 = 300;
  4. const byte = @intCast(u8, spartan_count);
  5. std.debug.print("value: {}\n", .{byte});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3584984 panic: integer cast truncated bits
  4. docgen_tmp/test.zig:5:18: 0x210326 in main (test)
  5. const byte = @intCast(u8, spartan_count);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f87c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f381 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

To truncate bits, use @truncate.

Integer Overflow

Default Operations

The following operators can cause integer overflow:

Example with addition at compile-time:

test.zig

  1. comptime {
  2. var byte: u8 = 255;
  3. byte += 1;
  4. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:10: error: overflow of integer type 'u8' with value '256'
  3. byte += 1;
  4. ~~~~~^~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var byte: u8 = 255;
  4. byte += 1;
  5. std.debug.print("value: {}\n", .{byte});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585038 panic: integer overflow
  4. docgen_tmp/test.zig:5:10: 0x210314 in main (test)
  5. byte += 1;
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f86c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f371 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Standard Library Math Functions

These functions provided by the standard library return possible errors.

  • @import("std").math.add
  • @import("std").math.sub
  • @import("std").math.mul
  • @import("std").math.divTrunc
  • @import("std").math.divFloor
  • @import("std").math.divExact
  • @import("std").math.shl

Example of catching an overflow for addition:

test.zig

  1. const math = @import("std").math;
  2. const print = @import("std").debug.print;
  3. pub fn main() !void {
  4. var byte: u8 = 255;
  5. byte = if (math.add(u8, byte, 1)) |result| result else |err| {
  6. print("unable to add one: {s}\n", .{@errorName(err)});
  7. return err;
  8. };
  9. print("result: {}\n", .{byte});
  10. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. unable to add one: Overflow
  4. error: Overflow
  5. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/math.zig:484:5: 0x210131 in add__anon_2905 (test)
  6. return if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer;
  7. ^
  8. docgen_tmp/test.zig:8:9: 0x210024 in main (test)
  9. return err;
  10. ^

Builtin Overflow Functions

These builtins return a bool of whether or not overflow occurred, as well as returning the overflowed bits:

Example of @addWithOverflow:

test.zig

  1. const print = @import("std").debug.print;
  2. pub fn main() void {
  3. var byte: u8 = 255;
  4. var result: u8 = undefined;
  5. if (@addWithOverflow(u8, byte, 10, &result)) {
  6. print("overflowed result: {}\n", .{result});
  7. } else {
  8. print("result: {}\n", .{result});
  9. }
  10. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. overflowed result: 9

Wrapping Operations

These operations have guaranteed wraparound semantics.

  • +% (wraparound addition)
  • -% (wraparound subtraction)
  • -% (wraparound negation)
  • *% (wraparound multiplication)

wraparound_semantics.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  3. const minInt = std.math.minInt;
  4. const maxInt = std.math.maxInt;
  5. test "wraparound addition and subtraction" {
  6. const x: i32 = maxInt(i32);
  7. const min_val = x +% 1;
  8. try expect(min_val == minInt(i32));
  9. const max_val = min_val -% 1;
  10. try expect(max_val == maxInt(i32));
  11. }

Shell

  1. $ zig test wraparound_semantics.zig
  2. 1/1 test.wraparound addition and subtraction... OK
  3. All 1 tests passed.

Exact Left Shift Overflow

At compile-time:

test.zig

  1. comptime {
  2. const x = @shlExact(@as(u8, 0b01010101), 2);
  3. _ = x;
  4. }

Shell

  1. $ zig test test.zig -fstage1
  2. ./docgen_tmp/test.zig:2:15: error: operation caused overflow
  3. const x = @shlExact(@as(u8, 0b01010101), 2);
  4. ^

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var x: u8 = 0b01010101;
  4. var y = @shlExact(x, 2);
  5. std.debug.print("value: {}\n", .{y});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585355 panic: left shift overflowed bits
  4. docgen_tmp/test.zig:5:13: 0x21032a in main (test)
  5. var y = @shlExact(x, 2);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f87c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f381 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Exact Right Shift Overflow

At compile-time:

test.zig

  1. comptime {
  2. const x = @shrExact(@as(u8, 0b10101010), 2);
  3. _ = x;
  4. }

Shell

  1. $ zig test test.zig -fstage1
  2. ./docgen_tmp/test.zig:2:15: error: exact shift shifted out 1 bits
  3. const x = @shrExact(@as(u8, 0b10101010), 2);
  4. ^

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var x: u8 = 0b10101010;
  4. var y = @shrExact(x, 2);
  5. std.debug.print("value: {}\n", .{y});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585494 panic: right shift overflowed bits
  4. docgen_tmp/test.zig:5:13: 0x210321 in main (test)
  5. var y = @shrExact(x, 2);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f87c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f381 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Division by Zero

At compile-time:

test.zig

  1. comptime {
  2. const a: i32 = 1;
  3. const b: i32 = 0;
  4. const c = a / b;
  5. _ = c;
  6. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:4:19: error: division by zero here causes undefined behavior
  3. const c = a / b;
  4. ^

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var a: u32 = 1;
  4. var b: u32 = 0;
  5. var c = a / b;
  6. std.debug.print("value: {}\n", .{c});
  7. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585604 panic: division by zero
  4. docgen_tmp/test.zig:6:15: 0x21034a in main (test)
  5. var c = a / b;
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f89c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f3a1 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Remainder Division by Zero

At compile-time:

test.zig

  1. comptime {
  2. const a: i32 = 10;
  3. const b: i32 = 0;
  4. const c = a % b;
  5. _ = c;
  6. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:4:19: error: division by zero here causes undefined behavior
  3. const c = a % b;
  4. ^

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var a: u32 = 10;
  4. var b: u32 = 0;
  5. var c = a % b;
  6. std.debug.print("value: {}\n", .{c});
  7. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585672 panic: division by zero
  4. docgen_tmp/test.zig:6:15: 0x21034a in main (test)
  5. var c = a % b;
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f89c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f3a1 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Exact Division Remainder

At compile-time:

test.zig

  1. comptime {
  2. const a: u32 = 10;
  3. const b: u32 = 3;
  4. const c = @divExact(a, b);
  5. _ = c;
  6. }

Shell

  1. $ zig test test.zig -fstage1
  2. ./docgen_tmp/test.zig:4:15: error: exact division had a remainder
  3. const c = @divExact(a, b);
  4. ^

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var a: u32 = 10;
  4. var b: u32 = 3;
  5. var c = @divExact(a, b);
  6. std.debug.print("value: {}\n", .{c});
  7. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585768 panic: exact division produced remainder
  4. docgen_tmp/test.zig:6:13: 0x2103b9 in main (test)
  5. var c = @divExact(a, b);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f8cc in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f3d1 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Attempt to Unwrap Null

At compile-time:

test.zig

  1. comptime {
  2. const optional_number: ?i32 = null;
  3. const number = optional_number.?;
  4. _ = number;
  5. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:35: error: unable to unwrap null
  3. const number = optional_number.?;
  4. ~~~~~~~~~~~~~~~^~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var optional_number: ?i32 = null;
  4. var number = optional_number.?;
  5. std.debug.print("value: {}\n", .{number});
  6. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3585872 panic: attempt to use null value
  4. docgen_tmp/test.zig:5:33: 0x210405 in main (test)
  5. var number = optional_number.?;
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f95c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f461 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

One way to avoid this crash is to test for null instead of assuming non-null, with the if expression:

test.zig

  1. const print = @import("std").debug.print;
  2. pub fn main() void {
  3. const optional_number: ?i32 = null;
  4. if (optional_number) |number| {
  5. print("got number: {}\n", .{number});
  6. } else {
  7. print("it's null\n", .{});
  8. }
  9. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. it's null

See also:

Attempt to Unwrap Error

At compile-time:

test.zig

  1. comptime {
  2. const number = getNumberOrFail() catch unreachable;
  3. _ = number;
  4. }
  5. fn getNumberOrFail() !i32 {
  6. return error.UnableToReturnNumber;
  7. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:2:44: error: caught unexpected error 'UnableToReturnNumber'
  3. const number = getNumberOrFail() catch unreachable;
  4. ^~~~~~~~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. const number = getNumberOrFail() catch unreachable;
  4. std.debug.print("value: {}\n", .{number});
  5. }
  6. fn getNumberOrFail() !i32 {
  7. return error.UnableToReturnNumber;
  8. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586023 panic: attempt to unwrap error: UnableToReturnNumber
  4. docgen_tmp/test.zig:9:5: 0x211f7f in getNumberOrFail (test)
  5. return error.UnableToReturnNumber;
  6. ^
  7. docgen_tmp/test.zig:4:44: 0x210411 in main (test)
  8. const number = getNumberOrFail() catch unreachable;
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f95c in posixCallMainAndExit (test)
  11. root.main();
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f461 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

One way to avoid this crash is to test for an error instead of assuming a successful result, with the if expression:

test.zig

  1. const print = @import("std").debug.print;
  2. pub fn main() void {
  3. const result = getNumberOrFail();
  4. if (result) |number| {
  5. print("got number: {}\n", .{number});
  6. } else |err| {
  7. print("got error: {s}\n", .{@errorName(err)});
  8. }
  9. }
  10. fn getNumberOrFail() !i32 {
  11. return error.UnableToReturnNumber;
  12. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. got error: UnableToReturnNumber

See also:

Invalid Error Code

At compile-time:

test.zig

  1. comptime {
  2. const err = error.AnError;
  3. const number = @errorToInt(err) + 10;
  4. const invalid_err = @intToError(number);
  5. _ = invalid_err;
  6. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:4:37: error: integer value '11' represents no error
  3. const invalid_err = @intToError(number);
  4. ^~~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. pub fn main() void {
  3. var err = error.AnError;
  4. var number = @errorToInt(err) + 500;
  5. var invalid_err = @intToError(number);
  6. std.debug.print("value: {}\n", .{invalid_err});
  7. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586118 panic: invalid error code
  4. docgen_tmp/test.zig:6:5: 0x2102ca in main (test)
  5. var invalid_err = @intToError(number);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f80c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f311 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Invalid Enum Cast

At compile-time:

test.zig

  1. const Foo = enum {
  2. a,
  3. b,
  4. c,
  5. };
  6. comptime {
  7. const a: u2 = 3;
  8. const b = @intToEnum(Foo, a);
  9. _ = b;
  10. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:8:15: error: enum 'test.Foo' has no tag with value '3'
  3. const b = @intToEnum(Foo, a);
  4. ^~~~~~~~~~~~~~~~~~
  5. docgen_tmp/test.zig:1:13: note: enum declared here
  6. const Foo = enum {
  7. ^~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. const Foo = enum {
  3. a,
  4. b,
  5. c,
  6. };
  7. pub fn main() void {
  8. var a: u2 = 3;
  9. var b = @intToEnum(Foo, a);
  10. std.debug.print("value: {s}\n", .{@tagName(b)});
  11. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586228 panic: invalid enum value
  4. docgen_tmp/test.zig:11:13: 0x210303 in main (test)
  5. var b = @intToEnum(Foo, a);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f85c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f361 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)

Invalid Error Set Cast

At compile-time:

test.zig

  1. const Set1 = error{
  2. A,
  3. B,
  4. };
  5. const Set2 = error{
  6. A,
  7. C,
  8. };
  9. comptime {
  10. _ = @errSetCast(Set2, Set1.B);
  11. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:10:9: error: 'error.B' not a member of error set 'error{A,C}'
  3. _ = @errSetCast(Set2, Set1.B);
  4. ^~~~~~~~~~~~~~~~~~~~~~~~~
  5. docgen_tmp/test.zig:5:14: note: error set declared here
  6. const Set2 = error{
  7. ^~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. const Set1 = error{
  3. A,
  4. B,
  5. };
  6. const Set2 = error{
  7. A,
  8. C,
  9. };
  10. pub fn main() void {
  11. foo(Set1.B);
  12. }
  13. fn foo(set1: Set1) void {
  14. const x = @errSetCast(Set2, set1);
  15. std.debug.print("value: {}\n", .{x});
  16. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586325 panic: invalid error code
  4. docgen_tmp/test.zig:15:15: 0x211e31 in foo (test)
  5. const x = @errSetCast(Set2, set1);
  6. ^
  7. docgen_tmp/test.zig:12:13: 0x21029d in main (test)
  8. foo(Set1.B);
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f82c in posixCallMainAndExit (test)
  11. root.main();
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f331 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

Incorrect Pointer Alignment

At compile-time:

test.zig

  1. comptime {
  2. const ptr = @intToPtr(*align(1) i32, 0x1);
  3. const aligned = @alignCast(4, ptr);
  4. _ = aligned;
  5. }

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes
  3. const aligned = @alignCast(4, ptr);
  4. ^~~

At runtime:

test.zig

  1. const mem = @import("std").mem;
  2. pub fn main() !void {
  3. var array align(4) = [_]u32{ 0x11111111, 0x11111111 };
  4. const bytes = mem.sliceAsBytes(array[0..]);
  5. if (foo(bytes) != 0x11111111) return error.Wrong;
  6. }
  7. fn foo(bytes: []u8) u32 {
  8. const slice4 = bytes[1..5];
  9. const int_slice = mem.bytesAsSlice(u32, @alignCast(4, slice4));
  10. return int_slice[0];
  11. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586365 panic: incorrect alignment
  4. docgen_tmp/test.zig:9:39: 0x20fecb in foo (test)
  5. const int_slice = mem.bytesAsSlice(u32, @alignCast(4, slice4));
  6. ^
  7. docgen_tmp/test.zig:5:12: 0x20fdff in main (test)
  8. if (foo(bytes) != 0x11111111) return error.Wrong;
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:614:37: 0x20f875 in posixCallMainAndExit (test)
  11. const result = root.main() catch |err| {
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f331 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

Wrong Union Field Access

At compile-time:

test.zig

  1. comptime {
  2. var f = Foo{ .int = 42 };
  3. f.float = 12.34;
  4. }
  5. const Foo = union {
  6. float: f32,
  7. int: u32,
  8. };

Shell

  1. $ zig test test.zig
  2. docgen_tmp/test.zig:3:6: error: access of union field 'float' while field 'int' is active
  3. f.float = 12.34;
  4. ~^~~~~~
  5. docgen_tmp/test.zig:6:13: note: union declared here
  6. const Foo = union {
  7. ^~~~~

At runtime:

test.zig

  1. const std = @import("std");
  2. const Foo = union {
  3. float: f32,
  4. int: u32,
  5. };
  6. pub fn main() void {
  7. var f = Foo{ .int = 42 };
  8. bar(&f);
  9. }
  10. fn bar(f: *Foo) void {
  11. f.float = 12.34;
  12. std.debug.print("value: {}\n", .{f.float});
  13. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586461 panic: access of inactive union field
  4. docgen_tmp/test.zig:14:6: 0x227a38 in bar (test)
  5. f.float = 12.34;
  6. ^
  7. docgen_tmp/test.zig:10:8: 0x225eac in main (test)
  8. bar(&f);
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x22542c in posixCallMainAndExit (test)
  11. root.main();
  12. ^
  13. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x224f31 in _start (test)
  14. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  15. ^
  16. (process terminated by signal)

This safety is not available for extern or packed unions.

To change the active field of a union, assign the entire union, like this:

test.zig

  1. const std = @import("std");
  2. const Foo = union {
  3. float: f32,
  4. int: u32,
  5. };
  6. pub fn main() void {
  7. var f = Foo{ .int = 42 };
  8. bar(&f);
  9. }
  10. fn bar(f: *Foo) void {
  11. f.* = Foo{ .float = 12.34 };
  12. std.debug.print("value: {}\n", .{f.float});
  13. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. value: 1.23400001e+01

To change the active field of a union when a meaningful value for the field is not known, use undefined, like this:

test.zig

  1. const std = @import("std");
  2. const Foo = union {
  3. float: f32,
  4. int: u32,
  5. };
  6. pub fn main() void {
  7. var f = Foo{ .int = 42 };
  8. f = Foo{ .float = undefined };
  9. bar(&f);
  10. std.debug.print("value: {}\n", .{f.float});
  11. }
  12. fn bar(f: *Foo) void {
  13. f.float = 12.34;
  14. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. value: 1.23400001e+01

See also:

Out of Bounds Float to Integer Cast

TODO

Pointer Cast Invalid Null

This happens when casting a pointer with the address 0 to a pointer which may not have the address 0. For example, C Pointers, Optional Pointers, and allowzero pointers allow address zero, but normal Pointers do not.

At compile-time:

test.zig

  1. comptime {
  2. const opt_ptr: ?*i32 = null;
  3. const ptr = @ptrCast(*i32, opt_ptr);
  4. _ = ptr;
  5. }

Shell

  1. $ zig test test.zig -fstage1
  2. ./docgen_tmp/test.zig:3:17: error: null pointer casted to type '*i32'
  3. const ptr = @ptrCast(*i32, opt_ptr);
  4. ^

At runtime:

test.zig

  1. pub fn main() void {
  2. var opt_ptr: ?*i32 = null;
  3. var ptr = @ptrCast(*i32, opt_ptr);
  4. _ = ptr;
  5. }

Shell

  1. $ zig build-exe test.zig
  2. $ ./test
  3. thread 3586695 panic: cast causes pointer to be null
  4. docgen_tmp/test.zig:3:15: 0x2101c1 in main (test)
  5. var ptr = @ptrCast(*i32, opt_ptr);
  6. ^
  7. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:604:22: 0x20f71c in posixCallMainAndExit (test)
  8. root.main();
  9. ^
  10. /home/ci/release-0.10.1/out/zig-x86_64-linux-musl-baseline/lib/zig/std/start.zig:376:5: 0x20f221 in _start (test)
  11. @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  12. ^
  13. (process terminated by signal)