Commit 3314fd83af
Changed files (5)
lib
src
codegen
lib/std/target.zig
@@ -1357,8 +1357,6 @@ pub const Target = struct {
}
};
- pub const stack_align = 16;
-
pub fn zigTriple(self: Target, allocator: mem.Allocator) ![]u8 {
return std.zig.CrossTarget.fromTarget(self).zigTriple(allocator);
}
@@ -1833,7 +1831,7 @@ pub const Target = struct {
};
}
- pub fn ptrBitWidth(target: std.Target) u16 {
+ pub fn ptrBitWidth(target: Target) u16 {
switch (target.abi) {
.gnux32, .muslx32, .gnuabin32, .gnuilp32 => return 32,
.gnuabi64 => return 64,
@@ -1910,6 +1908,18 @@ pub const Target = struct {
}
}
+ pub fn stackAlignment(target: Target) u16 {
+ return switch (target.cpu.arch) {
+ .x86 => switch (target.os.tag) {
+ .windows => 4,
+ else => 16,
+ },
+ .arm, .armeb, .mips, .mipsel => 8,
+ .aarch64, .aarch64_be, .powerpc64, .powerpc64le, .riscv64, .x86_64, .wasm32, .wasm64 => 16,
+ else => @divExact(target.ptrBitWidth(), 8),
+ };
+ }
+
/// Default signedness of `char` for the native C compiler for this target
/// Note that char signedness is implementation-defined and many compilers provide
/// an option to override the default signedness e.g. GCC's -funsigned-char / -fsigned-char
@@ -2428,7 +2438,7 @@ pub const Target = struct {
else => {},
},
.avr => switch (c_type) {
- .int, .uint, .long, .ulong, .float, .longdouble => return 1,
+ .char, .int, .uint, .long, .ulong, .float, .longdouble => return 1,
.short, .ushort => return 2,
.double => return 4,
.longlong, .ulonglong => return 8,
lib/test_runner.zig
@@ -136,7 +136,7 @@ fn mainTerminal() void {
const have_tty = progress.terminal != null and
(progress.supports_ansi_escape_codes or progress.is_windows_terminal);
- var async_frame_buffer: []align(std.Target.stack_align) u8 = undefined;
+ var async_frame_buffer: []align(builtin.target.stackAlignment()) u8 = undefined;
// TODO this is on the next line (using `undefined` above) because otherwise zig incorrectly
// ignores the alignment of the slice.
async_frame_buffer = &[_]u8{};
src/codegen/llvm/bindings.zig
@@ -1612,6 +1612,13 @@ pub const address_space = struct {
pub const constant_buffer_14: c_uint = 22;
pub const constant_buffer_15: c_uint = 23;
};
+
+ // See llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.h
+ pub const wasm = struct {
+ pub const variable = 1;
+ pub const externref = 10;
+ pub const funcref = 20;
+ };
};
pub const DIEnumerator = opaque {};
src/codegen/llvm/Builder.zig
@@ -17,6 +17,7 @@ string_indices: std.ArrayListUnmanaged(u32) = .{},
types: std.AutoArrayHashMapUnmanaged(String, Type) = .{},
next_unnamed_type: String = @enumFromInt(0),
+next_unique_type_id: std.AutoHashMapUnmanaged(String, u32) = .{},
type_map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
type_data: std.ArrayListUnmanaged(Type.Data) = .{},
type_extra: std.ArrayListUnmanaged(u32) = .{},
@@ -109,8 +110,10 @@ pub const Type = enum(u32) {
i1,
i8,
i16,
+ i29,
i32,
i64,
+ i80,
i128,
ptr,
@@ -173,17 +176,18 @@ pub const Type = enum(u32) {
if (std.enums.tagName(Type, data.type)) |name| return writer.writeAll(name);
const type_data = data.builder.type_data.items[@intFromEnum(data.type)];
switch (type_data.tag) {
+ .integer => try writer.print("i{d}", .{type_data.data}),
.named_structure => {
const extra = data.builder.typeExtraData(NamedStructure, type_data.data);
- if (comptime std.mem.eql(u8, fmt_str, "")) try writer.print("%{}", .{
- extra.id.fmt(data.builder),
- }) else if (comptime std.mem.eql(u8, fmt_str, "+")) switch (extra.child) {
+ if (comptime std.mem.eql(u8, fmt_str, "")) switch (extra.child) {
.none => try writer.writeAll("opaque"),
else => try format(.{
.type = extra.child,
.builder = data.builder,
}, fmt_str, fmt_opts, writer),
- } else @compileError("invalid format string: '" ++ fmt_str ++ "'");
+ } else if (comptime std.mem.eql(u8, fmt_str, "%")) try writer.print("%{}", .{
+ extra.id.fmt(data.builder),
+ }) else @compileError("invalid format string: '" ++ fmt_str ++ "'");
},
else => try writer.print("<type 0x{X}>", .{@intFromEnum(data.type)}),
}
@@ -220,7 +224,7 @@ pub const Linkage = enum {
};
pub const Preemption = enum {
- none,
+ default,
dso_preemptable,
dso_local,
@@ -230,7 +234,7 @@ pub const Preemption = enum {
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
- if (self == .none) return;
+ if (self == .default) return;
try writer.writeAll(@tagName(self));
try writer.writeByte(' ');
}
@@ -271,7 +275,7 @@ pub const DllStorageClass = enum {
};
pub const ThreadLocal = enum {
- none,
+ default,
generaldynamic,
localdynamic,
initialexec,
@@ -283,7 +287,7 @@ pub const ThreadLocal = enum {
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
- if (self == .none) return;
+ if (self == .default) return;
try writer.writeAll("thread_local");
if (self != .generaldynamic) {
try writer.writeByte('(');
@@ -295,7 +299,7 @@ pub const ThreadLocal = enum {
};
pub const UnnamedAddr = enum {
- none,
+ default,
unnamed_addr,
local_unnamed_addr,
@@ -305,14 +309,14 @@ pub const UnnamedAddr = enum {
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
- if (self == .none) return;
+ if (self == .default) return;
try writer.writeAll(@tagName(self));
try writer.writeByte(' ');
}
};
pub const AddrSpace = enum(u24) {
- none,
+ default,
_,
pub fn format(
@@ -321,13 +325,13 @@ pub const AddrSpace = enum(u24) {
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
- if (self == .none) return;
+ if (self == .default) return;
try writer.print("addrspace({d}) ", .{@intFromEnum(self)});
}
};
pub const ExternallyInitialized = enum {
- none,
+ default,
externally_initialized,
pub fn format(
@@ -336,7 +340,7 @@ pub const ExternallyInitialized = enum {
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
- if (self == .none) return;
+ if (self == .default) return;
try writer.writeAll(@tagName(self));
try writer.writeByte(' ');
}
@@ -369,12 +373,12 @@ pub const Alignment = enum(u6) {
pub const Global = struct {
linkage: Linkage = .default,
- preemption: Preemption = .none,
+ preemption: Preemption = .default,
visibility: Visibility = .default,
dll_storage_class: DllStorageClass = .default,
- unnamed_addr: UnnamedAddr = .none,
- addr_space: AddrSpace = .none,
- externally_initialized: ExternallyInitialized = .none,
+ unnamed_addr: UnnamedAddr = .default,
+ addr_space: AddrSpace = .default,
+ externally_initialized: ExternallyInitialized = .default,
type: Type,
alignment: Alignment = .default,
kind: union(enum) {
@@ -459,7 +463,7 @@ pub const Alias = struct {
pub const Object = struct {
global: Global.Index,
- thread_local: ThreadLocal = .none,
+ thread_local: ThreadLocal = .default,
mutability: enum { global, constant } = .global,
init: void = {},
@@ -525,7 +529,7 @@ pub fn init(self: *Builder) Allocator.Error!void {
@field(llvm.Context, simple_field.name ++ "Type")(self.llvm_context),
);
}
- inline for (.{ 1, 8, 16, 32, 64, 128 }) |bits| assert(self.intTypeAssumeCapacity(bits) ==
+ inline for (.{ 1, 8, 16, 29, 32, 64, 80, 128 }) |bits| assert(self.intTypeAssumeCapacity(bits) ==
@field(Type, std.fmt.comptimePrint("i{d}", .{bits})));
inline for (.{0}) |addr_space|
assert(self.pointerTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);
@@ -541,6 +545,7 @@ pub fn deinit(self: *Builder) void {
self.string_indices.deinit(self.gpa);
self.types.deinit(self.gpa);
+ self.next_unique_type_id.deinit(self.gpa);
self.type_map.deinit(self.gpa);
self.type_data.deinit(self.gpa);
self.type_extra.deinit(self.gpa);
@@ -596,13 +601,18 @@ pub fn fmtAssumeCapacity(self: *Builder, comptime fmt_str: []const u8, fmt_args:
}
pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
+ try self.string_map.ensureUnusedCapacity(self.gpa, 1);
+ try self.string_bytes.ensureUnusedCapacity(self.gpa, name.toSlice(self).?.len +
+ comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)}));
+ try self.string_indices.ensureUnusedCapacity(self.gpa, 1);
try self.types.ensureUnusedCapacity(self.gpa, 1);
+ try self.next_unique_type_id.ensureUnusedCapacity(self.gpa, 1);
try self.ensureUnusedCapacityTypes(1, Type.NamedStructure);
return self.opaqueTypeAssumeCapacity(name);
}
pub fn intType(self: *Builder, bits: u24) Allocator.Error!Type {
- try self.ensureUnusedCapacityTypes(1);
+ try self.ensureUnusedCapacityTypes(1, null);
return self.intTypeAssumeCapacity(bits);
}
@@ -695,27 +705,39 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
lhs == ctx.builder.typeExtraData(Type.NamedStructure, rhs_data.data).id;
}
};
- const id = if (name == .none) name: {
- const next_name = self.next_unnamed_type;
- assert(next_name != .none);
- self.next_unnamed_type = @enumFromInt(@intFromEnum(next_name) + 1);
- break :name next_name;
- } else name: {
- assert(name.toIndex() != null);
- break :name name;
- };
- const gop = self.type_map.getOrPutAssumeCapacityAdapted(id, Adapter{ .builder = self });
- if (!gop.found_existing) {
- gop.key_ptr.* = {};
- gop.value_ptr.* = {};
- self.type_data.appendAssumeCapacity(.{
- .tag = .named_structure,
- .data = self.addTypeExtraAssumeCapacity(Type.NamedStructure{ .id = id, .child = .none }),
- });
+ var id = name;
+ if (name == .none) {
+ id = self.next_unnamed_type;
+ assert(id != .none);
+ self.next_unnamed_type = @enumFromInt(@intFromEnum(id) + 1);
+ } else assert(name.toIndex() != null);
+ while (true) {
+ const type_gop = self.types.getOrPutAssumeCapacity(id);
+ if (!type_gop.found_existing) {
+ const gop = self.type_map.getOrPutAssumeCapacityAdapted(id, Adapter{ .builder = self });
+ assert(!gop.found_existing);
+ gop.key_ptr.* = {};
+ gop.value_ptr.* = {};
+ self.type_data.appendAssumeCapacity(.{
+ .tag = .named_structure,
+ .data = self.addTypeExtraAssumeCapacity(Type.NamedStructure{
+ .id = id,
+ .child = .none,
+ }),
+ });
+ const result: Type = @enumFromInt(gop.index);
+ type_gop.value_ptr.* = result;
+ if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
+ self.llvm_context.structCreateNamed(id.toSlice(self) orelse ""),
+ );
+ return result;
+ }
+
+ const unique_gop = self.next_unique_type_id.getOrPutAssumeCapacity(name);
+ if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;
+ id = self.fmtAssumeCapacity("{s}.{d}", .{ name.toSlice(self).?, unique_gop.value_ptr.* });
+ unique_gop.value_ptr.* += 1;
}
- const result: Type = @enumFromInt(gop.index);
- self.types.putAssumeCapacityNoClobber(id, result);
- return result;
}
fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type {
@@ -786,7 +808,7 @@ pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {
, .{self.target_triple.fmt(self)});
try writer.writeByte('\n');
for (self.types.keys(), self.types.values()) |id, ty| try writer.print(
- \\%{} = type {+}
+ \\%{} = type {}
\\
, .{ id.fmt(self), ty.fmt(self) });
try writer.writeByte('\n');
src/codegen/llvm.zig
@@ -328,6 +328,212 @@ pub fn supportsTailCall(target: std.Target) bool {
}
}
+const DataLayoutBuilder = struct {
+ target: std.Target,
+
+ pub fn format(
+ self: DataLayoutBuilder,
+ comptime _: []const u8,
+ _: std.fmt.FormatOptions,
+ writer: anytype,
+ ) @TypeOf(writer).Error!void {
+ const is_aarch64_windows = self.target.cpu.arch == .aarch64 and self.target.os.tag == .windows;
+ try writer.print("{c}-m:{c}", .{
+ @as(u8, switch (self.target.cpu.arch.endian()) {
+ .Little => 'e',
+ .Big => 'E',
+ }),
+ @as(u8, if (self.target.cpu.arch.isMIPS())
+ 'm' // Mips mangling: Private symbols get a $ prefix.
+ else switch (self.target.ofmt) {
+ .elf => 'e', // ELF mangling: Private symbols get a `.L` prefix.
+ //.goff => 'l', // GOFF mangling: Private symbols get a `@` prefix.
+ .macho => 'o', // Mach-O mangling: Private symbols get `L` prefix.
+ // Other symbols get a `_` prefix.
+ .coff => switch (self.target.os.tag) {
+ .windows => switch (self.target.cpu.arch) {
+ .x86 => 'x', // Windows x86 COFF mangling: Private symbols get the usual prefix.
+ // Regular C symbols get a `_` prefix. Functions with `__stdcall`, `__fastcall`,
+ // and `__vectorcall` have custom mangling that appends `@N` where N is the
+ // number of bytes used to pass parameters. C++ symbols starting with `?` are
+ // not mangled in any way.
+ else => 'w', // Windows COFF mangling: Similar to x, except that normal C
+ // symbols do not receive a `_` prefix.
+ },
+ else => 'e',
+ },
+ //.xcoff => 'a', // XCOFF mangling: Private symbols get a `L..` prefix.
+ else => 'e',
+ }),
+ });
+ var any_non_integral = false;
+ const ptr_bit_width = self.target.ptrBitWidth();
+ var default_info = struct { size: u16, abi: u16, pref: u16, idx: u16 }{
+ .size = 64,
+ .abi = 64,
+ .pref = 64,
+ .idx = 64,
+ };
+ const address_space_info = llvmAddressSpaceInfo(self.target);
+ assert(address_space_info[0].llvm == llvm.address_space.default);
+ for (address_space_info) |info| {
+ const is_default = info.llvm == llvm.address_space.default;
+ if (info.non_integral) {
+ assert(!is_default);
+ any_non_integral = true;
+ }
+ const size = info.size orelse ptr_bit_width;
+ const abi = info.abi orelse ptr_bit_width;
+ const pref = info.pref orelse abi;
+ const idx = info.idx orelse size;
+ const matches_default =
+ size == default_info.size and
+ abi == default_info.abi and
+ pref == default_info.pref and
+ idx == default_info.idx;
+ if (is_default) default_info = .{
+ .size = size,
+ .abi = abi,
+ .pref = pref,
+ .idx = idx,
+ };
+ if (!info.force_in_data_layout and matches_default and
+ self.target.cpu.arch != .riscv64 and !is_aarch64_windows) continue;
+ try writer.writeAll("-p");
+ if (!is_default) try writer.print("{d}", .{info.llvm});
+ try writer.print(":{d}:{d}", .{ size, abi });
+ if (pref != abi or idx != size) {
+ try writer.print(":{d}", .{pref});
+ if (idx != size) try writer.print(":{d}", .{idx});
+ }
+ }
+ if (self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb())
+ try writer.writeAll("-Fi8"); // for thumb interwork
+ try self.typeAlignment(.integer, 8, 8, 8, false, writer);
+ try self.typeAlignment(.integer, 16, 16, 16, false, writer);
+ try self.typeAlignment(.integer, 32, if (is_aarch64_windows) 0 else 32, 32, false, writer);
+ try self.typeAlignment(.integer, 64, 32, 64, false, writer);
+ try self.typeAlignment(.integer, 128, 32, 64, false, writer);
+ if (backendSupportsF16(self.target)) try self.typeAlignment(.float, 16, 16, 16, false, writer);
+ try self.typeAlignment(.float, 32, 32, 32, false, writer);
+ try self.typeAlignment(.float, 64, 64, 64, false, writer);
+ if (backendSupportsF80(self.target)) try self.typeAlignment(.float, 80, 0, 0, false, writer);
+ try self.typeAlignment(.float, 128, 128, 128, false, writer);
+ try self.typeAlignment(.vector, 64, 64, 64, false, writer);
+ try self.typeAlignment(.vector, 128, 128, 128, false, writer);
+ if (self.target.os.tag != .windows) try self.typeAlignment(.aggregate, 0, 0, 64, false, writer);
+ for (@as([]const u24, switch (self.target.cpu.arch) {
+ .aarch64_32,
+ .arm,
+ .armeb,
+ .mips,
+ .mipsel,
+ .powerpc,
+ .powerpcle,
+ .thumb,
+ .thumbeb,
+ .riscv32,
+ => &.{32},
+ .aarch64,
+ .aarch64_be,
+ .mips64,
+ .mips64el,
+ .powerpc64,
+ .powerpc64le,
+ .riscv64,
+ .wasm32,
+ .wasm64,
+ => &.{ 32, 64 },
+ .x86 => &.{ 8, 16, 32 },
+ .x86_64 => &.{ 8, 16, 32, 64 },
+ else => &.{},
+ }), 0..) |natural, index| switch (index) {
+ 0 => try writer.print("-n{d}", .{natural}),
+ else => try writer.print(":{d}", .{natural}),
+ };
+ if (self.target.os.tag == .windows) try self.typeAlignment(.aggregate, 0, 0, 64, false, writer);
+ const stack_abi = self.target.stackAlignment() * 8;
+ if (self.target.os.tag == .windows or stack_abi != ptr_bit_width)
+ try writer.print("-S{d}", .{stack_abi});
+ try self.typeAlignment(.vector, 256, 128, 128, true, writer);
+ try self.typeAlignment(.vector, 512, 128, 128, true, writer);
+ if (any_non_integral) {
+ try writer.writeAll("-ni");
+ for (address_space_info) |info| if (info.non_integral)
+ try writer.print(":{d}", .{info.llvm});
+ }
+ }
+
+ fn typeAlignment(
+ self: DataLayoutBuilder,
+ kind: enum { integer, vector, float, aggregate },
+ size: u24,
+ default_abi: u24,
+ default_pref: u24,
+ force_pref: bool,
+ writer: anytype,
+ ) @TypeOf(writer).Error!void {
+ var abi = default_abi;
+ var pref = default_pref;
+ if (kind == .float and size == 80) {
+ abi = 128;
+ pref = 128;
+ }
+ for (@as([]const std.Target.CType, switch (kind) {
+ .integer => &.{ .char, .short, .int, .long, .longlong },
+ .float => &.{ .float, .double, .longdouble },
+ .vector, .aggregate => &.{},
+ })) |cty| {
+ if (self.target.c_type_bit_size(cty) != size) continue;
+ abi = self.target.c_type_alignment(cty) * 8;
+ pref = self.target.c_type_preferred_alignment(cty) * 8;
+ break;
+ }
+ switch (kind) {
+ .integer => {
+ abi = @min(abi, self.target.maxIntAlignment() * 8);
+ switch (self.target.os.tag) {
+ .linux => switch (self.target.cpu.arch) {
+ .aarch64, .aarch64_be, .mips, .mipsel => pref = @max(pref, 32),
+ else => {},
+ },
+ else => {},
+ }
+ switch (self.target.cpu.arch) {
+ .aarch64, .aarch64_be, .riscv64 => switch (size) {
+ 128 => {
+ abi = size;
+ pref = size;
+ },
+ else => {},
+ },
+ else => {},
+ }
+ },
+ .vector => if (self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb()) {
+ switch (size) {
+ 128 => abi = 64,
+ else => {},
+ }
+ } else if (self.target.cpu.arch.isPPC64()) {
+ abi = size;
+ pref = size;
+ },
+ .float => {},
+ .aggregate => if (self.target.os.tag == .windows or
+ self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb())
+ {
+ pref = @min(pref, self.target.ptrBitWidth());
+ },
+ }
+ if (abi == default_abi and pref == default_pref) return;
+ try writer.print("-{c}", .{@tagName(kind)[0]});
+ if (size != 0) try writer.print("{d}", .{size});
+ try writer.print(":{d}", .{abi});
+ if (pref != abi or force_pref) try writer.print(":{d}", .{pref});
+ }
+};
+
/// TODO can this be done with simpler logic / different API binding?
fn deleteLlvmGlobal(llvm_global: *llvm.Value) void {
if (llvm_global.globalGetValueType().getTypeKind() == .Function) {
@@ -530,12 +736,17 @@ pub const Object = struct {
try builder.init();
errdefer builder.deinit();
builder.source_filename = try builder.string(options.root_name);
- builder.data_layout = rep: {
+ builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = options.target }});
+ builder.target_triple = try builder.string(llvm_target_triple);
+
+ if (std.debug.runtime_safety) {
const rep = target_data.stringRep();
defer llvm.disposeMessage(rep);
- break :rep try builder.string(std.mem.span(rep));
- };
- builder.target_triple = try builder.string(llvm_target_triple);
+ std.testing.expectEqualStrings(
+ std.mem.span(rep),
+ builder.data_layout.toSlice(&builder).?,
+ ) catch unreachable;
+ }
return Object{
.gpa = gpa,
@@ -768,6 +979,10 @@ pub const Object = struct {
if (comp.verbose_llvm_ir) |path| {
if (std.mem.eql(u8, path, "-")) {
self.llvm_module.dump();
+
+ const writer = std.io.getStdErr().writer();
+ try writer.writeAll("\n" ++ "-" ** 200 ++ "\n\n");
+ try self.builder.dump(writer);
} else {
const path_z = try comp.gpa.dupeZ(u8, path);
defer comp.gpa.free(path_z);
@@ -836,12 +1051,6 @@ pub const Object = struct {
emit_asm_msg, emit_bin_msg, emit_llvm_ir_msg, emit_llvm_bc_msg,
});
- {
- const writer = std.io.getStdErr().writer();
- try writer.writeAll("\n" ++ "-" ** 200 ++ "\n\n");
- try self.builder.dump(writer);
- }
-
// Unfortunately, LLVM shits the bed when we ask for both binary and assembly.
// So we call the entire pipeline multiple times if this is requested.
var error_message: [*:0]const u8 = undefined;
@@ -1311,7 +1520,7 @@ pub const Object = struct {
try global_index.rename(&self.builder, decl_name);
const decl_name_slice = decl_name.toSlice(&self.builder).?;
const global = global_index.ptr(&self.builder);
- global.unnamed_addr = .none;
+ global.unnamed_addr = .default;
llvm_global.setUnnamedAddr(.False);
global.linkage = .external;
llvm_global.setLinkage(.External);
@@ -2674,11 +2883,15 @@ pub const Object = struct {
const target = mod.getTarget();
- const llvm_type = try o.lowerLlvmType(decl.ty);
+ const ty = try o.lowerType(decl.ty);
+ const llvm_type = if (ty != .none)
+ o.builder.llvm_types.items[@intFromEnum(ty)]
+ else
+ try o.lowerLlvmType(decl.ty);
const llvm_actual_addrspace = toLlvmGlobalAddressSpace(decl.@"addrspace", target);
var global = Builder.Global{
- .type = .void,
+ .type = if (ty != .none) ty else .void,
.kind = .{ .object = @enumFromInt(o.builder.objects.items.len) },
};
var object = Builder.Object{
@@ -2698,7 +2911,7 @@ pub const Object = struct {
// This is needed for declarations created by `@extern`.
if (is_extern) {
- global.unnamed_addr = .none;
+ global.unnamed_addr = .default;
llvm_global.setUnnamedAddr(.False);
global.linkage = .external;
llvm_global.setLinkage(.External);
@@ -2708,7 +2921,7 @@ pub const Object = struct {
object.thread_local = .generaldynamic;
llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
} else {
- object.thread_local = .none;
+ object.thread_local = .default;
llvm_global.setThreadLocalMode(.NotThreadLocal);
}
if (variable.is_weak_linkage) {
@@ -2962,9 +3175,9 @@ pub const Object = struct {
const name = try o.builder.string(mod.intern_pool.stringToSlice(
try struct_obj.getFullyQualifiedName(mod),
));
- _ = try o.builder.opaqueType(name);
+ const ty = try o.builder.opaqueType(name);
- const llvm_struct_ty = o.context.structCreateNamed(name.toSlice(&o.builder).?);
+ const llvm_struct_ty = o.builder.llvm_types.items[@intFromEnum(ty)];
gop.value_ptr.* = llvm_struct_ty; // must be done before any recursive calls
assert(struct_obj.haveFieldTypes());
@@ -3101,16 +3314,6 @@ pub const Object = struct {
}
}
- fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
- const mod = o.module;
- switch (t.toIntern()) {
- .void_type, .noreturn_type => return .void,
- else => switch (mod.intern_pool.indexToKey(t.toIntern())) {
- else => return .none,
- },
- }
- }
-
fn lowerLlvmTypeFn(o: *Object, fn_ty: Type) Allocator.Error!*llvm.Type {
const mod = o.module;
const ip = &mod.intern_pool;
@@ -3206,6 +3409,149 @@ pub const Object = struct {
return llvm_elem_ty;
}
+ fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
+ const mod = o.module;
+ const target = mod.getTarget();
+ return switch (t.toIntern()) {
+ .u0_type, .i0_type => unreachable,
+ inline .u1_type,
+ .u8_type,
+ .i8_type,
+ .u16_type,
+ .i16_type,
+ .u29_type,
+ .u32_type,
+ .i32_type,
+ .u64_type,
+ .i64_type,
+ .u80_type,
+ .u128_type,
+ .i128_type,
+ => |tag| @field(Builder.Type, "i" ++ @tagName(tag)[1 .. @tagName(tag).len - "_type".len]),
+ .usize_type, .isize_type => try o.builder.intType(target.ptrBitWidth()),
+ inline .c_char_type,
+ .c_short_type,
+ .c_ushort_type,
+ .c_int_type,
+ .c_uint_type,
+ .c_long_type,
+ .c_ulong_type,
+ .c_longlong_type,
+ .c_ulonglong_type,
+ => |tag| try o.builder.intType(target.c_type_bit_size(
+ @field(std.Target.CType, @tagName(tag)["c_".len .. @tagName(tag).len - "_type".len]),
+ )),
+ .c_longdouble_type,
+ .f16_type,
+ .f32_type,
+ .f64_type,
+ .f80_type,
+ .f128_type,
+ => switch (t.floatBits(target)) {
+ 16 => if (backendSupportsF16(target)) .half else .i16,
+ 32 => .float,
+ 64 => .double,
+ 80 => if (backendSupportsF80(target)) .x86_fp80 else .i80,
+ 128 => .fp128,
+ else => unreachable,
+ },
+ .anyopaque_type => unreachable,
+ .bool_type => .i1,
+ .void_type => .void,
+ .type_type => unreachable,
+ .anyerror_type => .i16,
+ .comptime_int_type, .comptime_float_type, .noreturn_type => unreachable,
+ .anyframe_type => @panic("TODO implement lowerType for AnyFrame types"),
+ .null_type,
+ .undefined_type,
+ .enum_literal_type,
+ .atomic_order_type,
+ .atomic_rmw_op_type,
+ .calling_convention_type,
+ .address_space_type,
+ .float_mode_type,
+ .reduce_op_type,
+ .call_modifier_type,
+ .prefetch_options_type,
+ .export_options_type,
+ .extern_options_type,
+ .type_info_type,
+ => unreachable,
+ .manyptr_u8_type,
+ .manyptr_const_u8_type,
+ .manyptr_const_u8_sentinel_0_type,
+ .single_const_pointer_to_comptime_int_type,
+ => .ptr,
+ .slice_const_u8_type, .slice_const_u8_sentinel_0_type => .none,
+ .optional_noreturn_type => unreachable,
+ .anyerror_void_error_union_type => .i16,
+ .generic_poison_type, .empty_struct_type => unreachable,
+ // values, not types
+ .undef,
+ .zero,
+ .zero_usize,
+ .zero_u8,
+ .one,
+ .one_usize,
+ .one_u8,
+ .four_u8,
+ .negative_one,
+ .calling_convention_c,
+ .calling_convention_inline,
+ .void_value,
+ .unreachable_value,
+ .null_value,
+ .bool_true,
+ .bool_false,
+ .empty_struct,
+ .generic_poison,
+ .var_args_param_type,
+ .none,
+ => unreachable,
+ else => switch (mod.intern_pool.indexToKey(t.toIntern())) {
+ .int_type => |int_type| try o.builder.intType(int_type.bits),
+ .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
+ .One, .Many, .C => try o.builder.pointerType(@enumFromInt(
+ toLlvmAddressSpace(ptr_type.flags.address_space, target),
+ )),
+ .Slice => .none,
+ },
+ .array_type, .vector_type, .opt_type => .none,
+ .anyframe_type => @panic("TODO implement lowerType for AnyFrame types"),
+ .error_union_type => .none,
+ .simple_type => unreachable,
+ .struct_type,
+ .anon_struct_type,
+ .union_type,
+ .opaque_type,
+ => .none,
+ .enum_type => |enum_type| try o.lowerType(enum_type.tag_ty.toType()),
+ .func_type, .error_set_type, .inferred_error_set_type => .none,
+ // values, not types
+ .undef,
+ .runtime_value,
+ .simple_value,
+ .variable,
+ .extern_func,
+ .func,
+ .int,
+ .err,
+ .error_union,
+ .enum_literal,
+ .enum_tag,
+ .empty_enum_value,
+ .float,
+ .ptr,
+ .opt,
+ .aggregate,
+ .un,
+ // memoization, not types
+ .memoized_call,
+ => unreachable,
+ },
+ };
+ }
+
fn lowerValue(o: *Object, arg_tv: TypedValue) Error!*llvm.Value {
const mod = o.module;
const gpa = o.gpa;
@@ -10606,44 +10952,63 @@ fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) llvm.Ca
/// Convert a zig-address space to an llvm address space.
fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: std.Target) c_uint {
+ for (llvmAddressSpaceInfo(target)) |info| if (info.zig == address_space) return info.llvm;
+ unreachable;
+}
+
+const AddressSpaceInfo = struct {
+ zig: ?std.builtin.AddressSpace,
+ llvm: c_uint,
+ non_integral: bool = false,
+ size: ?u16 = null,
+ abi: ?u16 = null,
+ pref: ?u16 = null,
+ idx: ?u16 = null,
+ force_in_data_layout: bool = false,
+};
+fn llvmAddressSpaceInfo(target: std.Target) []const AddressSpaceInfo {
return switch (target.cpu.arch) {
- .x86, .x86_64 => switch (address_space) {
- .generic => llvm.address_space.default,
- .gs => llvm.address_space.x86.gs,
- .fs => llvm.address_space.x86.fs,
- .ss => llvm.address_space.x86.ss,
- else => unreachable,
+ .x86, .x86_64 => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.default },
+ .{ .zig = .gs, .llvm = llvm.address_space.x86.gs },
+ .{ .zig = .fs, .llvm = llvm.address_space.x86.fs },
+ .{ .zig = .ss, .llvm = llvm.address_space.x86.ss },
+ .{ .zig = null, .llvm = llvm.address_space.x86.ptr32_sptr, .size = 32, .abi = 32, .force_in_data_layout = true },
+ .{ .zig = null, .llvm = llvm.address_space.x86.ptr32_uptr, .size = 32, .abi = 32, .force_in_data_layout = true },
+ .{ .zig = null, .llvm = llvm.address_space.x86.ptr64, .size = 64, .abi = 64, .force_in_data_layout = true },
},
- .nvptx, .nvptx64 => switch (address_space) {
- .generic => llvm.address_space.default,
- .global => llvm.address_space.nvptx.global,
- .constant => llvm.address_space.nvptx.constant,
- .param => llvm.address_space.nvptx.param,
- .shared => llvm.address_space.nvptx.shared,
- .local => llvm.address_space.nvptx.local,
- else => unreachable,
+ .nvptx, .nvptx64 => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.default },
+ .{ .zig = .global, .llvm = llvm.address_space.nvptx.global },
+ .{ .zig = .constant, .llvm = llvm.address_space.nvptx.constant },
+ .{ .zig = .param, .llvm = llvm.address_space.nvptx.param },
+ .{ .zig = .shared, .llvm = llvm.address_space.nvptx.shared },
+ .{ .zig = .local, .llvm = llvm.address_space.nvptx.local },
},
- .amdgcn => switch (address_space) {
- .generic => llvm.address_space.amdgpu.flat,
- .global => llvm.address_space.amdgpu.global,
- .constant => llvm.address_space.amdgpu.constant,
- .shared => llvm.address_space.amdgpu.local,
- .local => llvm.address_space.amdgpu.private,
- else => unreachable,
+ .amdgcn => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.amdgpu.flat },
+ .{ .zig = .global, .llvm = llvm.address_space.amdgpu.global },
+ .{ .zig = .constant, .llvm = llvm.address_space.amdgpu.constant },
+ .{ .zig = .shared, .llvm = llvm.address_space.amdgpu.local },
+ .{ .zig = .local, .llvm = llvm.address_space.amdgpu.private },
},
- .avr => switch (address_space) {
- .generic => llvm.address_space.default,
- .flash => llvm.address_space.avr.flash,
- .flash1 => llvm.address_space.avr.flash1,
- .flash2 => llvm.address_space.avr.flash2,
- .flash3 => llvm.address_space.avr.flash3,
- .flash4 => llvm.address_space.avr.flash4,
- .flash5 => llvm.address_space.avr.flash5,
- else => unreachable,
+ .avr => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.default },
+ .{ .zig = .flash, .llvm = llvm.address_space.avr.flash },
+ .{ .zig = .flash1, .llvm = llvm.address_space.avr.flash1 },
+ .{ .zig = .flash2, .llvm = llvm.address_space.avr.flash2 },
+ .{ .zig = .flash3, .llvm = llvm.address_space.avr.flash3 },
+ .{ .zig = .flash4, .llvm = llvm.address_space.avr.flash4 },
+ .{ .zig = .flash5, .llvm = llvm.address_space.avr.flash5 },
},
- else => switch (address_space) {
- .generic => llvm.address_space.default,
- else => unreachable,
+ .wasm32, .wasm64 => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.default },
+ .{ .zig = null, .llvm = llvm.address_space.wasm.variable, .non_integral = true },
+ .{ .zig = null, .llvm = llvm.address_space.wasm.externref, .non_integral = true, .size = 8, .abi = 8 },
+ .{ .zig = null, .llvm = llvm.address_space.wasm.funcref, .non_integral = true, .size = 8, .abi = 8 },
+ },
+ else => &.{
+ .{ .zig = .generic, .llvm = llvm.address_space.default },
},
};
}