From e6b73be870a39f4da7a08a40da23e38b5e9613da Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 12 Oct 2023 21:54:59 -0700 Subject: [PATCH 1/2] Sema: fix crash when coercion dest is var args When analyzing the `as` ZIR instruction, an assertion would trip if the result type was a var args function argument. The fix is simple: inline a little bit of the `resolveType` logic into `analyzeAs` to make it detect this situation - which it was already attempting to do. Closes #16197 --- src/Sema.zig | 12 ++++++++++-- test/behavior/var_args.zig | 9 +++++++++ 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index c9dacd1185..559f5d2731 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -9846,11 +9846,19 @@ fn analyzeAs( const mod = sema.mod; const operand = try sema.resolveInst(zir_operand); if (zir_dest_type == .var_args_param_type) return operand; - const dest_ty = sema.resolveType(block, src, zir_dest_type) catch |err| switch (err) { + const operand_air_inst = sema.resolveInst(zir_dest_type) catch |err| switch (err) { error.GenericPoison => return operand, else => |e| return e, }; - if (dest_ty.zigTypeTag(mod) == .NoReturn) { + if (operand_air_inst == .var_args_param_type) return operand; + const dest_ty = sema.analyzeAsType(block, src, operand_air_inst) catch |err| switch (err) { + error.GenericPoison => return operand, + else => |e| return e, + }; + const dest_ty_tag = dest_ty.zigTypeTagOrPoison(mod) catch |err| switch (err) { + error.GenericPoison => return operand, + }; + if (dest_ty_tag == .NoReturn) { return sema.fail(block, src, "cannot cast to noreturn", .{}); } const is_ret = if (Zir.refToIndex(zir_dest_type)) |ptr_index| diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig index 134c302160..a2a00506f7 100644 --- a/test/behavior/var_args.zig +++ b/test/behavior/var_args.zig @@ -150,6 +150,15 @@ test "simple variadic function" { try std.testing.expectEqual(@as(c_int, 0), S.add(0)); try std.testing.expectEqual(@as(c_int, 1), S.add(1, @as(c_int, 1))); try std.testing.expectEqual(@as(c_int, 3), S.add(2, @as(c_int, 1), @as(c_int, 2))); + + { + // Test type coercion of a var args argument. + // Originally reported at https://github.com/ziglang/zig/issues/16197 + var runtime: bool = true; + var a: i32 = 1; + var b: i32 = 2; + try expect(1 == S.add(1, if (runtime) a else b)); + } } test "variadic functions" { From b6762c2473fc02e0fa71212a5556f4aed3f1942c Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 13 Oct 2023 00:31:22 -0700 Subject: [PATCH 2/2] Sema: fix crash when ref coercion dest is var args When analyzing the `validate_ref_ty` ZIR instruction, an assertion would trip if the result type was a var args function argument. The fix is the same as e6b73be870a39f4da7a08a40da23e38b5e9613da - inline the logic of `resolveType` and handle the case of var args. Closes #17494 --- src/Sema.zig | 16 +++++++++++----- test/behavior/var_args.zig | 31 +++++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 559f5d2731..0f3ae46c1b 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -4371,13 +4371,19 @@ fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr const mod = sema.mod; const un_tok = sema.code.instructions.items(.data)[inst].un_tok; const src = un_tok.src(); - const ty_operand = sema.resolveType(block, src, un_tok.operand) catch |err| switch (err) { - error.GenericPoison => { - // We don't actually have a type, so this will be treated as an untyped address-of operator. - return; - }, + // In case of GenericPoison, we don't actually have a type, so this will be + // treated as an untyped address-of operator. + if (un_tok.operand == .var_args_param_type) return; + const operand_air_inst = sema.resolveInst(un_tok.operand) catch |err| switch (err) { + error.GenericPoison => return, else => |e| return e, }; + if (operand_air_inst == .var_args_param_type) return; + const ty_operand = sema.analyzeAsType(block, src, operand_air_inst) catch |err| switch (err) { + error.GenericPoison => return, + else => |e| return e, + }; + if (ty_operand.isGenericPoison()) return; if (ty_operand.optEuBaseType(mod).zigTypeTag(mod) != .Pointer) { return sema.failWithOwnedErrorMsg(block, msg: { const msg = try sema.errMsg(block, src, "expected type '{}', found pointer", .{ty_operand.fmt(mod)}); diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig index a2a00506f7..d2a9817a96 100644 --- a/test/behavior/var_args.zig +++ b/test/behavior/var_args.zig @@ -161,6 +161,37 @@ test "simple variadic function" { } } +test "coerce reference to var arg" { + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.os.tag != .macos and comptime builtin.cpu.arch.isAARCH64()) { + // https://github.com/ziglang/zig/issues/14096 + return error.SkipZigTest; + } + if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; // TODO + + const S = struct { + fn addPtr(count: c_int, ...) callconv(.C) c_int { + var ap = @cVaStart(); + defer @cVaEnd(&ap); + var i: usize = 0; + var sum: c_int = 0; + while (i < count) : (i += 1) { + sum += @cVaArg(&ap, *c_int).*; + } + return sum; + } + }; + + // Originally reported at https://github.com/ziglang/zig/issues/17494 + var a: i32 = 12; + var b: i32 = 34; + try expect(46 == S.addPtr(2, &a, &b)); +} + test "variadic functions" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO