mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-01-25 00:35:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Sema: implement functions generic across callconv() or align()

Browse Source
This commit is contained in:
Andrew Kelley 2022-05-30 14:16:28 -07:00
parent 7e98b047dd
commit bd89a73d52
3 changed files with 125 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
src/Sema.zig
View File

@ -6547,7 +6547,7 @@ fn zirFunc(
inst,
0,
target_util.defaultAddressSpace(target, .function),
null,
FuncLinkSection.default,
cc,
ret_ty,
false,
@ -6660,15 +6660,26 @@ fn handleExternLibName(
return sema.gpa.dupeZ(u8, lib_name);
}
const FuncLinkSection = union(enum) {
generic,
default,
explicit: [*:0]const u8,
};
fn funcCommon(
sema: *Sema,
block: *Block,
src_node_offset: i32,
func_inst: Zir.Inst.Index,
alignment: u32,
address_space: std.builtin.AddressSpace,
section: ?[*:0]const u8,
cc: std.builtin.CallingConvention,
/// null means generic poison
alignment: ?u32,
/// null means generic poison
address_space: ?std.builtin.AddressSpace,
/// outer null means generic poison; inner null means default link section
section: FuncLinkSection,
/// null means generic poison
cc: ?std.builtin.CallingConvention,
/// this might be Type.generic_poison
bare_return_type: Type,
var_args: bool,
inferred_error_set: bool,
@ -6679,7 +6690,11 @@ fn funcCommon(
) CompileError!Air.Inst.Ref {
const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
var is_generic = bare_return_type.tag() == .generic_poison;
var is_generic = bare_return_type.tag() == .generic_poison or
alignment == null or
address_space == null or
section == .generic or
cc == null;
// Check for generic params.
for (block.params.items) |param| {
if (param.ty.tag() == .generic_poison) is_generic = true;
@ -6700,25 +6715,28 @@ fn funcCommon(
errdefer if (maybe_inferred_error_set_node) |node| sema.gpa.destroy(node);
// Note: no need to errdefer since this will still be in its default state at the end of the function.
const target = sema.mod.getTarget();
const fn_ty: Type = fn_ty: {
// Hot path for some common function types.
// TODO can we eliminate some of these Type tag values? seems unnecessarily complicated.
if (!is_generic and block.params.items.len == 0 and !var_args and
alignment == 0 and !inferred_error_set)
if (!is_generic and block.params.items.len == 0 and !var_args and !inferred_error_set and
alignment.? == 0 and
address_space.? == target_util.defaultAddressSpace(target, .function) and
section == .default)
{
if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
if (bare_return_type.zigTypeTag() == .NoReturn and cc.? == .Unspecified) {
break :fn_ty Type.initTag(.fn_noreturn_no_args);
}
if (bare_return_type.zigTypeTag() == .Void and cc == .Unspecified) {
if (bare_return_type.zigTypeTag() == .Void and cc.? == .Unspecified) {
break :fn_ty Type.initTag(.fn_void_no_args);
}
if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Naked) {
if (bare_return_type.zigTypeTag() == .NoReturn and cc.? == .Naked) {
break :fn_ty Type.initTag(.fn_naked_noreturn_no_args);
}
if (bare_return_type.zigTypeTag() == .Void and cc == .C) {
if (bare_return_type.zigTypeTag() == .Void and cc.? == .C) {
break :fn_ty Type.initTag(.fn_ccc_void_no_args);
}
}
@ -6764,21 +6782,33 @@ fn funcCommon(
});
};
// stage1 bug workaround
const cc_workaround = cc orelse undefined;
const align_workaround = alignment orelse @as(u32, undefined);
break :fn_ty try Type.Tag.function.create(sema.arena, .{
.param_types = param_types,
.comptime_params = comptime_params.ptr,
.return_type = return_type,
.cc = cc,
.alignment = alignment,
.cc = cc_workaround,
.cc_is_generic = cc == null,
.alignment = align_workaround,
.align_is_generic = alignment == null,
.section_is_generic = section == .generic,
.addrspace_is_generic = address_space == null,
.is_var_args = var_args,
.is_generic = is_generic,
});
};
if (sema.owner_decl.owns_tv) {
sema.owner_decl.@"linksection" = section;
sema.owner_decl.@"align" = alignment;
sema.owner_decl.@"addrspace" = address_space;
switch (section) {
.generic => sema.owner_decl.@"linksection" = undefined,
.default => sema.owner_decl.@"linksection" = null,
.explicit => |s| sema.owner_decl.@"linksection" = s,
}
if (alignment) |a| sema.owner_decl.@"align" = a;
if (address_space) |a| sema.owner_decl.@"addrspace" = a;
}
if (is_extern) {
@ -16780,13 +16810,16 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
break :blk lib_name;
} else null;
const @"align": u32 = if (extra.data.bits.has_align_body) blk: {
const @"align": ?u32 = if (extra.data.bits.has_align_body) blk: {
const body_len = sema.code.extra[extra_index];
extra_index += 1;
const body = sema.code.extra[extra_index..][0..body_len];
extra_index += body.len;
const val = try sema.resolveGenericBody(block, align_src, body, inst, Type.u16);
if (val.tag() == .generic_poison) {
break :blk null;
}
const alignment = @intCast(u32, val.toUnsignedInt(target));
if (alignment == target_util.defaultFunctionAlignment(target)) {
break :blk 0;
@ -16796,7 +16829,12 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
} else if (extra.data.bits.has_align_ref) blk: {
const align_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
extra_index += 1;
const align_tv = try sema.resolveInstConst(block, align_src, align_ref);
const align_tv = sema.resolveInstConst(block, align_src, align_ref) catch |err| switch (err) {
error.GenericPoison => {
break :blk null;
},
else => |e| return e,
};
const alignment = @intCast(u32, align_tv.val.toUnsignedInt(target));
if (alignment == target_util.defaultFunctionAlignment(target)) {
break :blk 0;
@ -16805,7 +16843,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
}
} else 0;
const @"addrspace": std.builtin.AddressSpace = if (extra.data.bits.has_addrspace_body) blk: {
const @"addrspace": ?std.builtin.AddressSpace = if (extra.data.bits.has_addrspace_body) blk: {
const body_len = sema.code.extra[extra_index];
extra_index += 1;
const body = sema.code.extra[extra_index..][0..body_len];
@ -16813,32 +16851,48 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
const addrspace_ty = try sema.getBuiltinType(block, addrspace_src, "AddressSpace");
const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty);
if (val.tag() == .generic_poison) {
break :blk null;
}
break :blk val.toEnum(std.builtin.AddressSpace);
} else if (extra.data.bits.has_addrspace_ref) blk: {
const addrspace_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
extra_index += 1;
const addrspace_tv = try sema.resolveInstConst(block, addrspace_src, addrspace_ref);
const addrspace_tv = sema.resolveInstConst(block, addrspace_src, addrspace_ref) catch |err| switch (err) {
error.GenericPoison => {
break :blk null;
},
else => |e| return e,
};
break :blk addrspace_tv.val.toEnum(std.builtin.AddressSpace);
} else target_util.defaultAddressSpace(target, .function);
const @"linksection": ?[*:0]const u8 = if (extra.data.bits.has_section_body) {
const @"linksection": FuncLinkSection = if (extra.data.bits.has_section_body) blk: {
const body_len = sema.code.extra[extra_index];
extra_index += 1;
const body = sema.code.extra[extra_index..][0..body_len];
extra_index += body.len;
const val = try sema.resolveGenericBody(block, section_src, body, inst, Type.initTag(.const_slice_u8));
if (val.tag() == .generic_poison) {
break :blk FuncLinkSection{ .generic = {} };
}
_ = val;
return sema.fail(block, section_src, "TODO implement linksection on functions", .{});
} else if (extra.data.bits.has_section_ref) {
} else if (extra.data.bits.has_section_ref) blk: {
const section_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
extra_index += 1;
const section_tv = try sema.resolveInstConst(block, section_src, section_ref);
const section_tv = sema.resolveInstConst(block, section_src, section_ref) catch |err| switch (err) {
error.GenericPoison => {
break :blk FuncLinkSection{ .generic = {} };
},
else => |e| return e,
};
_ = section_tv;
return sema.fail(block, section_src, "TODO implement linksection on functions", .{});
} else null;
} else FuncLinkSection{ .default = {} };
const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc_body) blk: {
const cc: ?std.builtin.CallingConvention = if (extra.data.bits.has_cc_body) blk: {
const body_len = sema.code.extra[extra_index];
extra_index += 1;
const body = sema.code.extra[extra_index..][0..body_len];
@ -16846,13 +16900,21 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
const cc_ty = try sema.getBuiltinType(block, addrspace_src, "CallingConvention");
const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty);
if (val.tag() == .generic_poison) {
break :blk null;
}
break :blk val.toEnum(std.builtin.CallingConvention);
} else if (extra.data.bits.has_cc_ref) blk: {
const cc_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
extra_index += 1;
const cc_tv = try sema.resolveInstConst(block, cc_src, cc_ref);
const cc_tv = sema.resolveInstConst(block, cc_src, cc_ref) catch |err| switch (err) {
error.GenericPoison => {
break :blk null;
},
else => |e| return e,
};
break :blk cc_tv.val.toEnum(std.builtin.CallingConvention);
} else .Unspecified;
} else std.builtin.CallingConvention.Unspecified;
const ret_ty: Type = if (extra.data.bits.has_ret_ty_body) blk: {
const body_len = sema.code.extra[extra_index];

4
src/type.zig
View File

@ -6120,6 +6120,10 @@ pub const Type = extern union {
cc: std.builtin.CallingConvention,
is_var_args: bool,
is_generic: bool,
align_is_generic: bool = false,
cc_is_generic: bool = false,
section_is_generic: bool = false,
addrspace_is_generic: bool = false,
pub fn paramIsComptime(self: @This(), i: usize) bool {
assert(i < self.param_types.len);

43
test/behavior/align.zig
View File

@ -334,25 +334,44 @@ fn simple4() align(4) i32 {
return 0x19;
}
test "generic function with align param" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
test "function align expression depends on generic parameter" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
// function alignment is a compile error on wasm32/wasm64
if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
if (native_arch == .thumb) return error.SkipZigTest;
try expect(whyWouldYouEverDoThis(1) == 0x1);
try expect(whyWouldYouEverDoThis(4) == 0x1);
try expect(whyWouldYouEverDoThis(8) == 0x1);
const S = struct {
fn doTheTest() !void {
try expect(foobar(1) == 2);
try expect(foobar(4) == 5);
try expect(foobar(8) == 9);
}
fn foobar(comptime align_bytes: u8) align(align_bytes) u8 {
return align_bytes + 1;
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 {
_ = align_bytes;
return 0x1;
test "function callconv expression depends on generic parameter" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try expect(foobar(.C, 1) == 2);
try expect(foobar(.Unspecified, 2) == 3);
}
fn foobar(comptime cc: std.builtin.CallingConvention, arg: u8) callconv(cc) u8 {
return arg + 1;
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "runtime known array index has best alignment possible" {