Nixyri/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-25 13:50:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: update for CallingConvention changes

Browse Source 
This also includes some compiler and std changes to correct error
messages which weren't properly updated before.
This commit is contained in:
mlugg 2024-10-13 17:56:47 +01:00
parent ec19086aa0
commit 4be0cf30fc
No known key found for this signature in database
GPG Key ID: 3F5B7DCCBF4AF02E
41 changed files with 154 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/std/Target.zig
View File

@ -1612,7 +1612,7 @@ pub const Cpu = struct {
/// Returns the array of `Arch` to which a specific `std.builtin.CallingConvention` applies.
/// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
pub fn fromCallconv(cc: std.builtin.CallingConvention) []const Arch {
pub fn fromCallconv(cc: std.builtin.CallingConvention.Tag) []const Arch {
return switch (cc) {
.auto,
.@"async",

8
lib/std/builtin.zig
View File

@ -173,7 +173,7 @@ pub const CallingConvention = union(enum(u8)) {
/// Functions marked as `extern` or `export` are given this calling convention by default.
pub const c = builtin.target.defaultCCallingConvention().?;
pub const winapi: CallingConvention = switch (builtin.target.arch) {
pub const winapi: CallingConvention = switch (builtin.target.cpu.arch) {
.x86_64 => .{ .x86_64_win = .{} },
.x86 => .{ .x86_stdcall = .{} },
.aarch64, .aarch64_be => .{ .aarch64_aapcs_win = .{} },
@ -481,7 +481,9 @@ pub const CallingConvention = union(enum(u8)) {
/// Returns the array of `std.Target.Cpu.Arch` to which this `CallingConvention` applies.
/// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
pub const archs = std.Target.Cpu.Arch.fromCallconv;
pub fn archs(cc: CallingConvention) []const std.Target.Cpu.Arch {
return std.Target.Cpu.Arch.fromCallconv(cc);
}
pub fn eql(a: CallingConvention, b: CallingConvention) bool {
return std.meta.eql(a, b);
@ -490,7 +492,7 @@ pub const CallingConvention = union(enum(u8)) {
pub fn withStackAlign(cc: CallingConvention, incoming_stack_alignment: u64) CallingConvention {
const tag: CallingConvention.Tag = cc;
var result = cc;
@field(result, tag).incoming_stack_alignment = incoming_stack_alignment;
@field(result, @tagName(tag)).incoming_stack_alignment = incoming_stack_alignment;
return result;
}
};

37
src/Sema.zig
View File

@ -9711,25 +9711,32 @@ fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention.Tag) bool {
}
fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.builtin.CallingConvention.Tag) CompileError!void {
const CallingConventionsSupportingVarArgsList = struct {
pub fn format(_: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
arch: std.Target.Cpu.Arch,
pub fn format(ctx: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
for (calling_conventions_supporting_var_args, 0..) |cc_inner, i| {
if (i != 0)
var first = true;
for (calling_conventions_supporting_var_args) |cc_inner| {
for (std.Target.Cpu.Arch.fromCallconv(cc_inner)) |supported_arch| {
if (supported_arch == ctx.arch) break;
} else continue; // callconv not supported by this arch
if (!first) {
try writer.writeAll(", ");
try writer.print("'.{s}'", .{@tagName(cc_inner)});
}
first = false;
try writer.print("'{s}'", .{@tagName(cc_inner)});
}
}
};
if (!callConvSupportsVarArgs(cc)) {
const msg = msg: {
const msg = try sema.errMsg(src, "variadic function does not support '.{s}' calling convention", .{@tagName(cc)});
return sema.failWithOwnedErrorMsg(block, msg: {
const msg = try sema.errMsg(src, "variadic function does not support '{s}' calling convention", .{@tagName(cc)});
errdefer msg.destroy(sema.gpa);
try sema.errNote(src, msg, "supported calling conventions: {}", .{CallingConventionsSupportingVarArgsList{}});
const target = sema.pt.zcu.getTarget();
try sema.errNote(src, msg, "supported calling conventions: {}", .{CallingConventionsSupportingVarArgsList{ .arch = target.cpu.arch }});
break :msg msg;
};
return sema.failWithOwnedErrorMsg(block, msg);
});
}
}
@ -9857,9 +9864,9 @@ fn funcCommon(
.x86_64_interrupt, .x86_interrupt => {
const err_code_size = target.ptrBitWidth();
switch (i) {
0 => if (param_ty.zigTypeTag(zcu) != .pointer) return sema.fail(block, param_src, "first parameter of function with 'Interrupt' calling convention must be a pointer type", .{}),
1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with 'Interrupt' calling convention must be a {d}-bit integer", .{err_code_size}),
else => return sema.fail(block, param_src, "'Interrupt' calling convention supports up to 2 parameters, found {d}", .{i + 1}),
0 => if (param_ty.zigTypeTag(zcu) != .pointer) return sema.fail(block, param_src, "first parameter of function with '{s}' calling convention must be a pointer type", .{@tagName(cc_resolved)}),
1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with '{s}' calling convention must be a {d}-bit integer", .{ @tagName(cc_resolved), err_code_size }),
else => return sema.fail(block, param_src, "'{s}' calling convention supports up to 2 parameters, found {d}", .{ @tagName(cc_resolved), i + 1 }),
}
},
.arm_interrupt,
@ -9870,8 +9877,8 @@ fn funcCommon(
.avr_interrupt,
.csky_interrupt,
.m68k_interrupt,
=> return sema.fail(block, param_src, "parameters are not allowed with 'Interrupt' calling convention", .{}),
.avr_signal => return sema.fail(block, param_src, "parameters are not allowed with 'Signal' calling convention", .{}),
=> return sema.fail(block, param_src, "parameters are not allowed with '{s}' calling convention", .{@tagName(cc_resolved)}),
.avr_signal => return sema.fail(block, param_src, "parameters are not allowed with '{s}' calling convention", .{@tagName(cc_resolved)}),
else => {},
}
}
@ -10220,7 +10227,7 @@ fn finishFunc(
for (formatter.archs, 0..) |arch, i| {
if (i != 0)
try writer.writeAll(", ");
try writer.print("'.{s}'", .{@tagName(arch)});
try writer.print("'{s}'", .{@tagName(arch)});
}
}
};

5
src/Type.zig
View File

@ -397,7 +397,10 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
break :print_cc;
}
}
try writer.print("callconv({any}) ", .{fn_info.cc});
switch (fn_info.cc) {
.auto, .@"async", .naked, .@"inline" => try writer.print("callconv(.{}) ", .{std.zig.fmtId(@tagName(fn_info.cc))}),
else => try writer.print("callconv({any}) ", .{fn_info.cc}),
}
}
if (fn_info.return_type == .generic_poison_type) {
try writer.writeAll("anytype");

3
src/arch/riscv64/CodeGen.zig
View File

@ -18,6 +18,7 @@ const Zcu = @import("../../Zcu.zig");
const Package = @import("../../Package.zig");
const InternPool = @import("../../InternPool.zig");
const Compilation = @import("../../Compilation.zig");
const target_util = @import("../../target.zig");
const trace = @import("../../tracy.zig").trace;
const codegen = @import("../../codegen.zig");
@ -821,7 +822,7 @@ pub fn generate(
@intFromEnum(FrameIndex.stack_frame),
FrameAlloc.init(.{
.size = 0,
.alignment = func.analysisUnordered(ip).stack_alignment.max(.@"1"),
.alignment = .fromByteUnits(target_util.stackAlignment(function.target.*, fn_type.fnCallingConvention(zcu))),
}),
);
function.frame_allocs.set(

2
src/arch/x86_64/CodeGen.zig
View File

@ -873,7 +873,7 @@ pub fn generate(
@intFromEnum(FrameIndex.stack_frame),
FrameAlloc.init(.{
.size = 0,
.alignment = target_util.stackAlignment(function.target.*, fn_type.fnCallingConvention(zcu)),
.alignment = .fromByteUnits(target_util.stackAlignment(function.target.*, fn_type.fnCallingConvention(zcu))),
}),
);
function.frame_allocs.set(

9
test/behavior/align.zig
View File

@ -210,15 +210,6 @@ test "alignment and size of structs with 128-bit fields" {
}
}
test "alignstack" {
try expect(fnWithAlignedStack() == 1234);
}
fn fnWithAlignedStack() i32 {
@setAlignStack(256);
return 1234;
}
test "implicitly decreasing slice alignment" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

1
test/behavior/builtin_functions_returning_void_or_noreturn.zig
View File

@ -20,7 +20,6 @@ test {
try testing.expectEqual({}, @memset(@as([*]u8, @ptrFromInt(1))[0..0], undefined));
try testing.expectEqual(noreturn, @TypeOf(if (true) @panic("") else {}));
try testing.expectEqual({}, @prefetch(&val, .{}));
try testing.expectEqual({}, @setAlignStack(16));
try testing.expectEqual({}, @setEvalBranchQuota(0));
try testing.expectEqual({}, @setFloatMode(.optimized));
try testing.expectEqual({}, @setRuntimeSafety(true));

8
test/behavior/type_info.zig
View File

@ -358,7 +358,7 @@ test "type info: function type info" {
fn testFunction() !void {
const foo_fn_type = @TypeOf(typeInfoFoo);
const foo_fn_info = @typeInfo(foo_fn_type);
try expect(foo_fn_info.@"fn".calling_convention == .C);
try expect(foo_fn_info.@"fn".calling_convention.eql(.c));
try expect(!foo_fn_info.@"fn".is_generic);
try expect(foo_fn_info.@"fn".params.len == 2);
try expect(foo_fn_info.@"fn".is_var_args);
@ -374,7 +374,7 @@ fn testFunction() !void {
const aligned_foo_fn_type = @TypeOf(typeInfoFooAligned);
const aligned_foo_fn_info = @typeInfo(aligned_foo_fn_type);
try expect(aligned_foo_fn_info.@"fn".calling_convention == .C);
try expect(aligned_foo_fn_info.@"fn".calling_convention.eql(.c));
try expect(!aligned_foo_fn_info.@"fn".is_generic);
try expect(aligned_foo_fn_info.@"fn".params.len == 2);
try expect(aligned_foo_fn_info.@"fn".is_var_args);
@ -390,8 +390,8 @@ fn testFunction() !void {
try expect(aligned_foo_ptr_fn_info.pointer.sentinel == null);
}
extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.C) usize;
extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.c) usize;
extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.c) usize;
test "type info: generic function types" {
const G1 = @typeInfo(@TypeOf(generic1));

6
test/behavior/typename.zig
View File

@ -79,9 +79,9 @@ test "basic" {
try expectEqualStrings("fn (comptime u32) void", @typeName(fn (comptime u32) void));
try expectEqualStrings("fn (noalias []u8) void", @typeName(fn (noalias []u8) void));
try expectEqualStrings("fn () callconv(.C) void", @typeName(fn () callconv(.C) void));
try expectEqualStrings("fn (...) callconv(.C) void", @typeName(fn (...) callconv(.C) void));
try expectEqualStrings("fn (u32, ...) callconv(.C) void", @typeName(fn (u32, ...) callconv(.C) void));
try expectEqualStrings("fn () callconv(.c) void", @typeName(fn () callconv(.c) void));
try expectEqualStrings("fn (...) callconv(.c) void", @typeName(fn (...) callconv(.c) void));
try expectEqualStrings("fn (u32, ...) callconv(.c) void", @typeName(fn (u32, ...) callconv(.c) void));
}
test "top level decl" {

7
test/cases/compile_errors/array_in_c_exported_function.zig
View File

@ -7,10 +7,9 @@ export fn zig_return_array() [10]u8 {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:21: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
// :1:21: error: parameter of type '[10]u8' not allowed in function with calling convention 'x86_64_sysv'
// :1:21: note: arrays are not allowed as a parameter type
// :5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
// :5:30: error: return type '[10]u8' not allowed in function with calling convention 'x86_64_sysv'
// :5:30: note: arrays are not allowed as a return type

2
test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
View File

@ -8,5 +8,5 @@ inline fn b() void {}
// backend=stage2
// target=native
//
// :2:9: error: variable of type '*const fn () callconv(.Inline) void' must be const or comptime
// :2:9: error: variable of type '*const fn () callconv(.@"inline") void' must be const or comptime
// :2:9: note: function has inline calling convention

2
test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
View File

@ -1,7 +1,7 @@
const Foo = packed struct(u32) {
x: u1,
};
fn bar(_: Foo) callconv(.C) void {}
fn bar(_: Foo) callconv(.c) void {}
pub export fn entry() void {
bar(.{ .x = 0 });
}

7
test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
View File

@ -3,9 +3,8 @@ export fn entry2() callconv(.AAPCS) void {}
export fn entry3() callconv(.AAPCSVFP) void {}
// error
// backend=stage2
// target=x86_64-linux-none
//
// :1:30: error: callconv 'APCS' is only available on ARM, not x86_64
// :2:30: error: callconv 'AAPCS' is only available on ARM, not x86_64
// :3:30: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64
// :1:30: error: callconv 'arm_apcs' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'
// :2:30: error: callconv 'arm_aapcs' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'
// :3:30: error: callconv 'arm_aapcs_vfp' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'

4
test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
View File

@ -1,7 +1,7 @@
export fn entry() callconv(.Signal) void {}
export fn entry() callconv(.avr_signal) void {}
// error
// backend=stage2
// target=x86_64-linux-none
//
// :1:29: error: callconv 'Signal' is only available on AVR, not x86_64
// :1:29: error: callconv 'avr_signal' only available on architectures 'avr'

12
test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
View File

@ -1,6 +1,6 @@
const F1 = fn () callconv(.Stdcall) void;
const F2 = fn () callconv(.Fastcall) void;
const F3 = fn () callconv(.Thiscall) void;
const F1 = fn () callconv(.{ .x86_stdcall = .{} }) void;
const F2 = fn () callconv(.{ .x86_fastcall = .{} }) void;
const F3 = fn () callconv(.{ .x86_thiscall = .{} }) void;
export fn entry1() void {
const a: F1 = undefined;
_ = a;
@ -18,6 +18,6 @@ export fn entry3() void {
// backend=stage2
// target=x86_64-linux-none
//
// :1:28: error: callconv 'Stdcall' is only available on x86, not x86_64
// :2:28: error: callconv 'Fastcall' is only available on x86, not x86_64
// :3:28: error: callconv 'Thiscall' is only available on x86, not x86_64
// :1:28: error: callconv 'x86_stdcall' only available on architectures 'x86'
// :2:28: error: callconv 'x86_fastcall' only available on architectures 'x86'
// :3:28: error: callconv 'x86_thiscall' only available on architectures 'x86'

7
test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig
View File

@ -1,7 +0,0 @@
export fn entry() callconv(.Vectorcall) void {}
// error
// backend=stage2
// target=x86_64-linux-none
//
// :1:29: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64

2
test/cases/compile_errors/closure_get_depends_on_failed_decl.zig
View File

@ -4,7 +4,7 @@ pub inline fn requestAdapter(
comptime callbackArg: fn () callconv(.Inline) void,
) void {
_ = &(struct {
pub fn callback() callconv(.C) void {
pub fn callback() callconv(.c) void {
callbackArg();
}
}).callback;

5
test/cases/compile_errors/export_function_with_comptime_parameter.zig
View File

@ -3,7 +3,6 @@ export fn foo(comptime x: anytype, y: i32) i32 {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:15: error: comptime parameters not allowed in function with calling convention 'C'
// :1:15: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'

5
test/cases/compile_errors/export_generic_function.zig
View File

@ -4,7 +4,6 @@ export fn foo(num: anytype) i32 {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:15: error: generic parameters not allowed in function with calling convention 'C'
// :1:15: error: generic parameters not allowed in function with calling convention 'x86_64_sysv'

7
test/cases/compile_errors/extern_function_pointer_mismatch.zig
View File

@ -14,8 +14,7 @@ export fn entry() usize {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:38: error: expected type 'fn (i32) i32', found 'fn (i32) callconv(.C) i32'
// :1:38: note: calling convention 'C' cannot cast into calling convention 'Unspecified'
// :1:38: error: expected type 'fn (i32) i32', found 'fn (i32) callconv(.c) i32'
// :1:38: note: calling convention 'x86_64_sysv' cannot cast into calling convention 'auto'

9
test/cases/compile_errors/extern_function_with_comptime_parameter.zig
View File

@ -15,9 +15,8 @@ comptime {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:15: error: comptime parameters not allowed in function with calling convention 'C'
// :5:30: error: comptime parameters not allowed in function with calling convention 'C'
// :6:30: error: generic parameters not allowed in function with calling convention 'C'
// :1:15: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'
// :5:30: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'
// :6:30: error: generic parameters not allowed in function with calling convention 'x86_64_sysv'

29
test/cases/compile_errors/function-only_builtins_outside_function.zig
View File

@ -1,7 +1,3 @@
comptime {
@setAlignStack(1);
}
comptime {
@branchHint(.cold);
}
@ -54,16 +50,15 @@ comptime {
// backend=stage2
// target=native
//
// :2:5: error: '@setAlignStack' outside function scope
// :6:5: error: '@branchHint' outside function scope
// :10:5: error: '@src' outside function scope
// :14:5: error: '@returnAddress' outside function scope
// :18:5: error: '@frameAddress' outside function scope
// :22:5: error: '@breakpoint' outside function scope
// :26:5: error: '@cVaArg' outside function scope
// :30:5: error: '@cVaCopy' outside function scope
// :34:5: error: '@cVaEnd' outside function scope
// :38:5: error: '@cVaStart' outside function scope
// :42:5: error: '@workItemId' outside function scope
// :46:5: error: '@workGroupSize' outside function scope
// :50:5: error: '@workGroupId' outside function scope
// :2:5: error: '@branchHint' outside function scope
// :6:5: error: '@src' outside function scope
// :10:5: error: '@returnAddress' outside function scope
// :14:5: error: '@frameAddress' outside function scope
// :18:5: error: '@breakpoint' outside function scope
// :22:5: error: '@cVaArg' outside function scope
// :26:5: error: '@cVaCopy' outside function scope
// :30:5: error: '@cVaEnd' outside function scope
// :34:5: error: '@cVaStart' outside function scope
// :38:5: error: '@workItemId' outside function scope
// :42:5: error: '@workGroupSize' outside function scope
// :46:5: error: '@workGroupId' outside function scope

5
test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
View File

@ -4,10 +4,9 @@ export fn entry(foo: Foo) void {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :2:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
// :2:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
// :2:17: note: enum tag type 'u2' is not extern compatible
// :2:17: note: only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible
// :1:13: note: enum declared here

5
test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
View File

@ -8,9 +8,8 @@ export fn entry(foo: Foo) void {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
// :6:17: note: only extern structs and ABI sized packed structs are extern compatible
// :1:13: note: struct declared here

5
test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
View File

@ -8,9 +8,8 @@ export fn entry(foo: Foo) void {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'x86_64_sysv'
// :6:17: note: only extern unions and ABI sized packed unions are extern compatible
// :1:13: note: union declared here

2
test/cases/compile_errors/invalid_extern_function_call.zig
View File

@ -1,4 +1,4 @@
const x = @extern(*const fn () callconv(.C) void, .{ .name = "foo" });
const x = @extern(*const fn () callconv(.c) void, .{ .name = "foo" });
export fn entry0() void {
comptime x();

15
test/cases/compile_errors/invalid_func_for_callconv.zig
View File

@ -9,12 +9,11 @@ export fn signal_param(_: u32) callconv(.Signal) void {}
export fn signal_ret() callconv(.Signal) noreturn {}
// error
// backend=stage2
// target=x86_64-linux
//
// :1:28: error: first parameter of function with 'Interrupt' calling convention must be a pointer type
// :2:43: error: second parameter of function with 'Interrupt' calling convention must be a 64-bit integer
// :3:51: error: 'Interrupt' calling convention supports up to 2 parameters, found 3
// :4:69: error: function with calling convention 'Interrupt' must return 'void' or 'noreturn'
// :8:24: error: parameters are not allowed with 'Signal' calling convention
// :9:34: error: callconv 'Signal' is only available on AVR, not x86_64
//
// :1:28: error: first parameter of function with 'x86_64_interrupt' calling convention must be a pointer type
// :2:43: error: second parameter of function with 'x86_64_interrupt' calling convention must be a 64-bit integer
// :3:51: error: 'x86_64_interrupt' calling convention supports up to 2 parameters, found 3
// :4:69: error: function with calling convention 'x86_64_interrupt' must return 'void' or 'noreturn'
// :8:24: error: parameters are not allowed with 'avr_signal' calling convention
// :9:34: error: callconv 'avr_signal' only available on architectures 'avr'

2
test/cases/compile_errors/invalid_tail_call.zig
View File

@ -9,4 +9,4 @@ pub export fn entry() void {
// backend=llvm
// target=native
//
// :5:5: error: unable to perform tail call: type of function being called 'fn (usize) void' does not match type of calling function 'fn () callconv(.C) void'
// :5:5: error: unable to perform tail call: type of function being called 'fn (usize) void' does not match type of calling function 'fn () callconv(.c) void'

11
test/cases/compile_errors/invalid_variadic_function.zig
View File

@ -13,11 +13,10 @@ comptime {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:1: error: variadic function does not support '.Unspecified' calling convention
// :1:1: note: supported calling conventions: '.C'
// :1:1: error: variadic function does not support '.Inline' calling convention
// :1:1: note: supported calling conventions: '.C'
// :1:1: error: variadic function does not support 'auto' calling convention
// :1:1: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'
// :1:1: error: variadic function does not support 'inline' calling convention
// :1:1: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'
// :2:1: error: generic function cannot be variadic

5
test/cases/compile_errors/noinline_fn_cc_inline.zig
View File

@ -1,5 +1,4 @@
const cc = .Inline;
noinline fn foo() callconv(cc) void {}
noinline fn foo() callconv(.@"inline") void {}
comptime {
_ = foo;
@ -9,4 +8,4 @@ comptime {
// backend=stage2
// target=native
//
// :2:28: error: 'noinline' function cannot have callconv 'Inline'
// :1:29: error: 'noinline' function cannot have callconv 'inline'

8
test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
View File

@ -1,20 +1,20 @@
const S = extern struct {
a: fn () callconv(.C) void,
a: fn () callconv(.c) void,
};
comptime {
_ = @sizeOf(S) == 1;
}
comptime {
_ = [*c][4]fn () callconv(.C) void;
_ = [*c][4]fn () callconv(.c) void;
}
// error
// backend=stage2
// target=native
//
// :2:8: error: extern structs cannot contain fields of type 'fn () callconv(.C) void'
// :2:8: error: extern structs cannot contain fields of type 'fn () callconv(.c) void'
// :2:8: note: type has no guaranteed in-memory representation
// :2:8: note: use '*const ' to make a function pointer type
// :8:13: error: C pointers cannot point to non-C-ABI-compatible type '[4]fn () callconv(.C) void'
// :8:13: error: C pointers cannot point to non-C-ABI-compatible type '[4]fn () callconv(.c) void'
// :8:13: note: type has no guaranteed in-memory representation
// :8:13: note: use '*const ' to make a function pointer type

7
test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
View File

@ -12,8 +12,7 @@ comptime {
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:13: error: variadic function does not support '.Unspecified' calling convention
// :1:13: note: supported calling conventions: '.C'
// :1:13: error: variadic function does not support 'auto' calling convention
// :1:13: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'

4
test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
View File

@ -1,5 +1,5 @@
const GuSettings = struct {
fin: ?fn (c_int) callconv(.C) void,
fin: ?fn (c_int) callconv(.c) void,
};
pub export fn callbackFin(id: c_int, arg: ?*anyopaque) void {
const settings: ?*GuSettings = @as(?*GuSettings, @ptrFromInt(@intFromPtr(arg)));
@ -13,4 +13,4 @@ pub export fn callbackFin(id: c_int, arg: ?*anyopaque) void {
//
// :5:54: error: pointer to comptime-only type '?*tmp.GuSettings' must be comptime-known, but operand is runtime-known
// :2:10: note: struct requires comptime because of this field
// :2:10: note: use '*const fn (c_int) callconv(.C) void' for a function pointer type
// :2:10: note: use '*const fn (c_int) callconv(.c) void' for a function pointer type

9
test/cases/compile_errors/setAlignStack_in_naked_function.zig
View File

@ -1,9 +0,0 @@
export fn entry() callconv(.Naked) void {
@setAlignStack(16);
}
// error
// backend=stage2
// target=native
//
// :2:5: error: @setAlignStack in naked function

9
test/cases/compile_errors/setAlignStack_too_big.zig
View File

@ -1,9 +0,0 @@
export fn entry() void {
@setAlignStack(511 + 1);
}
// error
// backend=stage2
// target=native
//
// :2:5: error: attempt to @setAlignStack(512); maximum is 256

7
test/cases/compile_errors/slice_used_as_extern_fn_param.zig
View File

@ -1,11 +1,10 @@
extern fn Text(str: []const u8, num: i32) callconv(.C) void;
extern fn Text(str: []const u8, num: i32) callconv(.c) void;
export fn entry() void {
_ = Text;
}
// error
// backend=stage2
// target=native
// target=x86_64-linux
//
// :1:16: error: parameter of type '[]const u8' not allowed in function with calling convention 'C'
// :1:16: error: parameter of type '[]const u8' not allowed in function with calling convention 'x86_64_sysv'
// :1:16: note: slices have no guaranteed in-memory representation

4
test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig
View File

@ -1,4 +1,4 @@
const fn_ty = ?fn ([*c]u8, ...) callconv(.C) void;
const fn_ty = ?fn ([*c]u8, ...) callconv(.c) void;
extern fn fn_decl(fmt: [*:0]u8, ...) void;
export fn main() void {
@ -10,6 +10,6 @@ export fn main() void {
// backend=stage2
// target=native
//
// :5:22: error: expected type '?fn ([*c]u8, ...) callconv(.C) void', found 'fn ([*:0]u8, ...) callconv(.C) void'
// :5:22: error: expected type '?fn ([*c]u8, ...) callconv(.c) void', found 'fn ([*:0]u8, ...) callconv(.c) void'
// :5:22: note: parameter 0 '[*:0]u8' cannot cast into '[*c]u8'
// :5:22: note: '[*c]u8' could have null values which are illegal in type '[*:0]u8'

2
test/cases/compile_errors/wrong_types_given_to_export.zig
View File

@ -1,4 +1,4 @@
fn entry() callconv(.C) void {}
fn entry() callconv(.c) void {}
comptime {
@export(&entry, .{ .name = "entry", .linkage = @as(u32, 1234) });
}

2
test/cases/translate_c/static empty struct.c
View File

@ -9,7 +9,7 @@ static inline void foo() {
// c_frontend=clang
//
// pub const struct_empty_struct = extern struct {};
// pub fn foo() callconv(.C) void {
// pub fn foo() callconv(.c) void {
// const bar = struct {
// var static: struct_empty_struct = @import("std").mem.zeroes(struct_empty_struct);
// };

68
test/translate_c.zig
View File

@ -484,11 +484,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ fnptr_attr_ty qux;
\\};
, &[_][]const u8{
\\pub const fnptr_ty = ?*const fn () callconv(.C) void;
\\pub const fnptr_attr_ty = ?*const fn () callconv(.C) void;
\\pub const fnptr_ty = ?*const fn () callconv(.c) void;
\\pub const fnptr_attr_ty = ?*const fn () callconv(.c) void;
\\pub const struct_foo = extern struct {
\\ foo: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
\\ bar: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
\\ foo: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
\\ bar: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
\\ baz: fnptr_ty = @import("std").mem.zeroes(fnptr_ty),
\\ qux: fnptr_attr_ty = @import("std").mem.zeroes(fnptr_attr_ty),
\\};
@ -735,7 +735,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\static void bar(void) {}
, &[_][]const u8{
\\pub export fn foo() void {}
\\pub fn bar() callconv(.C) void {}
\\pub fn bar() callconv(.c) void {}
});
cases.add("typedef void",
@ -769,7 +769,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub export fn bar() void {
\\ var func_ptr: ?*anyopaque = @as(?*anyopaque, @ptrCast(&foo));
\\ _ = &func_ptr;
\\ var typed_func_ptr: ?*const fn () callconv(.C) void = @as(?*const fn () callconv(.C) void, @ptrFromInt(@as(c_ulong, @intCast(@intFromPtr(func_ptr)))));
\\ var typed_func_ptr: ?*const fn () callconv(.c) void = @as(?*const fn () callconv(.c) void, @ptrFromInt(@as(c_ulong, @intCast(@intFromPtr(func_ptr)))));
\\ _ = &typed_func_ptr;
\\}
});
@ -839,9 +839,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ lws_callback_function *callback_http;
\\};
, &[_][]const u8{
\\pub const lws_callback_function = fn () callconv(.C) void;
\\pub const lws_callback_function = fn () callconv(.c) void;
\\pub const struct_Foo = extern struct {
\\ func: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
\\ func: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
\\ callback_http: ?*const lws_callback_function = @import("std").mem.zeroes(?*const lws_callback_function),
\\};
});
@ -867,7 +867,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\};
, &[_][]const u8{
\\pub const struct_Foo = extern struct {
\\ derp: ?*const fn ([*c]struct_Foo) callconv(.C) void = @import("std").mem.zeroes(?*const fn ([*c]struct_Foo) callconv(.C) void),
\\ derp: ?*const fn ([*c]struct_Foo) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_Foo) callconv(.c) void),
\\};
,
\\pub const Foo = struct_Foo;
@ -1111,7 +1111,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.add("__cdecl doesn't mess up function pointers",
\\void foo(void (__cdecl *fn_ptr)(void));
, &[_][]const u8{
\\pub extern fn foo(fn_ptr: ?*const fn () callconv(.C) void) void;
\\pub extern fn foo(fn_ptr: ?*const fn () callconv(.c) void) void;
});
cases.add("void cast",
@ -1477,8 +1477,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\typedef void (*fn0)();
\\typedef void (*fn1)(char);
, &[_][]const u8{
\\pub const fn0 = ?*const fn (...) callconv(.C) void;
\\pub const fn1 = ?*const fn (u8) callconv(.C) void;
\\pub const fn0 = ?*const fn (...) callconv(.c) void;
\\pub const fn1 = ?*const fn (u8) callconv(.c) void;
});
cases.addWithTarget("Calling convention", .{
@ -1492,11 +1492,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\void __attribute__((cdecl)) foo4(float *a);
\\void __attribute__((thiscall)) foo5(float *a);
, &[_][]const u8{
\\pub extern fn foo1(a: [*c]f32) callconv(.Fastcall) void;
\\pub extern fn foo2(a: [*c]f32) callconv(.Stdcall) void;
\\pub extern fn foo3(a: [*c]f32) callconv(.Vectorcall) void;
\\pub extern fn foo1(a: [*c]f32) callconv(.{ .x86_fastcall = .{} }) void;
\\pub extern fn foo2(a: [*c]f32) callconv(.{ .x86_stdcall = .{} }) void;
\\pub extern fn foo3(a: [*c]f32) callconv(.{ .x86_vectorcall = .{} }) void;
\\pub extern fn foo4(a: [*c]f32) void;
\\pub extern fn foo5(a: [*c]f32) callconv(.Thiscall) void;
\\pub extern fn foo5(a: [*c]f32) callconv(.{ .x86_thiscall = .{} }) void;
});
cases.addWithTarget("Calling convention", std.Target.Query.parse(.{
@ -1506,8 +1506,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\void __attribute__((pcs("aapcs"))) foo1(float *a);
\\void __attribute__((pcs("aapcs-vfp"))) foo2(float *a);
, &[_][]const u8{
\\pub extern fn foo1(a: [*c]f32) callconv(.AAPCS) void;
\\pub extern fn foo2(a: [*c]f32) callconv(.AAPCSVFP) void;
\\pub extern fn foo1(a: [*c]f32) callconv(.{ .arm_aapcs = .{} }) void;
\\pub extern fn foo2(a: [*c]f32) callconv(.{ .arm_aapcs_vfp = .{} }) void;
});
cases.addWithTarget("Calling convention", std.Target.Query.parse(.{
@ -1516,7 +1516,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
}) catch unreachable,
\\void __attribute__((aarch64_vector_pcs)) foo1(float *a);
, &[_][]const u8{
\\pub extern fn foo1(a: [*c]f32) callconv(.Vectorcall) void;
\\pub extern fn foo1(a: [*c]f32) callconv(.{ .aarch64_vfabi = .{} }) void;
});
cases.add("Parameterless function prototypes",
@ -1533,8 +1533,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub export fn b() void {}
\\pub extern fn c(...) void;
\\pub extern fn d() void;
\\pub fn e() callconv(.C) void {}
\\pub fn f() callconv(.C) void {}
\\pub fn e() callconv(.c) void {}
\\pub fn f() callconv(.c) void {}
\\pub extern fn g() void;
\\pub extern fn h() void;
});
@ -1555,7 +1555,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ char *arr1[10] ={0};
\\}
, &[_][]const u8{
\\pub fn foo() callconv(.C) void {
\\pub fn foo() callconv(.c) void {
\\ var arr: [10]u8 = [1]u8{
\\ 1,
\\ } ++ [1]u8{0} ** 9;
@ -1686,13 +1686,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\extern char (*fn_ptr2)(int, float);
\\#define bar fn_ptr2
, &[_][]const u8{
\\pub extern var fn_ptr: ?*const fn () callconv(.C) void;
\\pub extern var fn_ptr: ?*const fn () callconv(.c) void;
,
\\pub inline fn foo() void {
\\ return fn_ptr.?();
\\}
,
\\pub extern var fn_ptr2: ?*const fn (c_int, f32) callconv(.C) u8;
\\pub extern var fn_ptr2: ?*const fn (c_int, f32) callconv(.c) u8;
,
\\pub inline fn bar(arg_1: c_int, arg_2: f32) u8 {
\\ return fn_ptr2.?(arg_1, arg_2);
@ -1714,8 +1714,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\#define glClearPFN PFNGLCLEARPROC
, &[_][]const u8{
\\pub const GLbitfield = c_uint;
\\pub const PFNGLCLEARPROC = ?*const fn (GLbitfield) callconv(.C) void;
\\pub const OpenGLProc = ?*const fn () callconv(.C) void;
\\pub const PFNGLCLEARPROC = ?*const fn (GLbitfield) callconv(.c) void;
\\pub const OpenGLProc = ?*const fn () callconv(.c) void;
\\const struct_unnamed_1 = extern struct {
\\ Clear: PFNGLCLEARPROC = @import("std").mem.zeroes(PFNGLCLEARPROC),
\\};
@ -2691,9 +2691,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ return 0;
\\}
\\pub export fn bar() void {
\\ var f: ?*const fn () callconv(.C) void = &foo;
\\ var f: ?*const fn () callconv(.c) void = &foo;
\\ _ = &f;
\\ var b: ?*const fn () callconv(.C) c_int = &baz;
\\ var b: ?*const fn () callconv(.c) c_int = &baz;
\\ _ = &b;
\\ f.?();
\\ f.?();
@ -3048,8 +3048,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ baz();
\\}
, &[_][]const u8{
\\pub fn bar() callconv(.C) void {}
\\pub export fn foo(arg_baz: ?*const fn () callconv(.C) [*c]c_int) void {
\\pub fn bar() callconv(.c) void {}
\\pub export fn foo(arg_baz: ?*const fn () callconv(.c) [*c]c_int) void {
\\ var baz = arg_baz;
\\ _ = &baz;
\\ bar();
@ -3112,7 +3112,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ do {} while (0);
\\}
, &[_][]const u8{
\\pub fn foo() callconv(.C) void {
\\pub fn foo() callconv(.c) void {
\\ if (true) while (true) {
\\ if (!false) break;
\\ };
@ -3212,10 +3212,10 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\void c(void) {}
\\static void foo() {}
, &[_][]const u8{
\\pub fn a() callconv(.C) void {}
\\pub fn b() callconv(.C) void {}
\\pub fn a() callconv(.c) void {}
\\pub fn b() callconv(.c) void {}
\\pub export fn c() void {}
\\pub fn foo() callconv(.C) void {}
\\pub fn foo() callconv(.c) void {}
});
cases.add("casting away const and volatile",