authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-07-07 09:22:27-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-07-19 23:38:40-04:00
log3314fd83af5a6a269926a6f8ad3fcb62b04242c9
tree6a8f4fc3782b327cdee4f980a38b20ce67d57295
parentd195173ba2c06b56c1bf5554ebf0736795798c91

llvm: compute data layout without help like a grownup compiler

5 files changed, 511 insertions(+), 107 deletions(-)

lib/std/target.zig+14-4
...@@ -1357,8 +1357,6 @@ pub const Target = struct {...@@ -1357,8 +1357,6 @@ pub const Target = struct {
1357 }1357 }
1358 };1358 };
13591359
1360 pub const stack_align = 16;
1361
1362 pub fn zigTriple(self: Target, allocator: mem.Allocator) ![]u8 {1360 pub fn zigTriple(self: Target, allocator: mem.Allocator) ![]u8 {
1363 return std.zig.CrossTarget.fromTarget(self).zigTriple(allocator);1361 return std.zig.CrossTarget.fromTarget(self).zigTriple(allocator);
1364 }1362 }
...@@ -1833,7 +1831,7 @@ pub const Target = struct {...@@ -1833,7 +1831,7 @@ pub const Target = struct {
1833 };1831 };
1834 }1832 }
18351833
1836 pub fn ptrBitWidth(target: std.Target) u16 {1834 pub fn ptrBitWidth(target: Target) u16 {
1837 switch (target.abi) {1835 switch (target.abi) {
1838 .gnux32, .muslx32, .gnuabin32, .gnuilp32 => return 32,1836 .gnux32, .muslx32, .gnuabin32, .gnuilp32 => return 32,
1839 .gnuabi64 => return 64,1837 .gnuabi64 => return 64,
...@@ -1910,6 +1908,18 @@ pub const Target = struct {...@@ -1910,6 +1908,18 @@ pub const Target = struct {
1910 }1908 }
1911 }1909 }
19121910
1911 pub fn stackAlignment(target: Target) u16 {
1912 return switch (target.cpu.arch) {
1913 .x86 => switch (target.os.tag) {
1914 .windows => 4,
1915 else => 16,
1916 },
1917 .arm, .armeb, .mips, .mipsel => 8,
1918 .aarch64, .aarch64_be, .powerpc64, .powerpc64le, .riscv64, .x86_64, .wasm32, .wasm64 => 16,
1919 else => @divExact(target.ptrBitWidth(), 8),
1920 };
1921 }
1922
1913 /// Default signedness of `char` for the native C compiler for this target1923 /// Default signedness of `char` for the native C compiler for this target
1914 /// Note that char signedness is implementation-defined and many compilers provide1924 /// Note that char signedness is implementation-defined and many compilers provide
1915 /// an option to override the default signedness e.g. GCC's -funsigned-char / -fsigned-char1925 /// an option to override the default signedness e.g. GCC's -funsigned-char / -fsigned-char
...@@ -2428,7 +2438,7 @@ pub const Target = struct {...@@ -2428,7 +2438,7 @@ pub const Target = struct {
2428 else => {},2438 else => {},
2429 },2439 },
2430 .avr => switch (c_type) {2440 .avr => switch (c_type) {
2431 .int, .uint, .long, .ulong, .float, .longdouble => return 1,2441 .char, .int, .uint, .long, .ulong, .float, .longdouble => return 1,
2432 .short, .ushort => return 2,2442 .short, .ushort => return 2,
2433 .double => return 4,2443 .double => return 4,
2434 .longlong, .ulonglong => return 8,2444 .longlong, .ulonglong => return 8,
lib/test_runner.zig+1-1
...@@ -136,7 +136,7 @@ fn mainTerminal() void {...@@ -136,7 +136,7 @@ fn mainTerminal() void {
136 const have_tty = progress.terminal != null and136 const have_tty = progress.terminal != null and
137 (progress.supports_ansi_escape_codes or progress.is_windows_terminal);137 (progress.supports_ansi_escape_codes or progress.is_windows_terminal);
138138
139 var async_frame_buffer: []align(std.Target.stack_align) u8 = undefined;139 var async_frame_buffer: []align(builtin.target.stackAlignment()) u8 = undefined;
140 // TODO this is on the next line (using `undefined` above) because otherwise zig incorrectly140 // TODO this is on the next line (using `undefined` above) because otherwise zig incorrectly
141 // ignores the alignment of the slice.141 // ignores the alignment of the slice.
142 async_frame_buffer = &[_]u8{};142 async_frame_buffer = &[_]u8{};
src/codegen/llvm.zig+425-60
...@@ -328,6 +328,212 @@ pub fn supportsTailCall(target: std.Target) bool {...@@ -328,6 +328,212 @@ pub fn supportsTailCall(target: std.Target) bool {
328 }328 }
329}329}
330330
331const DataLayoutBuilder = struct {
332 target: std.Target,
333
334 pub fn format(
335 self: DataLayoutBuilder,
336 comptime _: []const u8,
337 _: std.fmt.FormatOptions,
338 writer: anytype,
339 ) @TypeOf(writer).Error!void {
340 const is_aarch64_windows = self.target.cpu.arch == .aarch64 and self.target.os.tag == .windows;
341 try writer.print("{c}-m:{c}", .{
342 @as(u8, switch (self.target.cpu.arch.endian()) {
343 .Little => 'e',
344 .Big => 'E',
345 }),
346 @as(u8, if (self.target.cpu.arch.isMIPS())
347 'm' // Mips mangling: Private symbols get a $ prefix.
348 else switch (self.target.ofmt) {
349 .elf => 'e', // ELF mangling: Private symbols get a `.L` prefix.
350 //.goff => 'l', // GOFF mangling: Private symbols get a `@` prefix.
351 .macho => 'o', // Mach-O mangling: Private symbols get `L` prefix.
352 // Other symbols get a `_` prefix.
353 .coff => switch (self.target.os.tag) {
354 .windows => switch (self.target.cpu.arch) {
355 .x86 => 'x', // Windows x86 COFF mangling: Private symbols get the usual prefix.
356 // Regular C symbols get a `_` prefix. Functions with `__stdcall`, `__fastcall`,
357 // and `__vectorcall` have custom mangling that appends `@N` where N is the
358 // number of bytes used to pass parameters. C++ symbols starting with `?` are
359 // not mangled in any way.
360 else => 'w', // Windows COFF mangling: Similar to x, except that normal C
361 // symbols do not receive a `_` prefix.
362 },
363 else => 'e',
364 },
365 //.xcoff => 'a', // XCOFF mangling: Private symbols get a `L..` prefix.
366 else => 'e',
367 }),
368 });
369 var any_non_integral = false;
370 const ptr_bit_width = self.target.ptrBitWidth();
371 var default_info = struct { size: u16, abi: u16, pref: u16, idx: u16 }{
372 .size = 64,
373 .abi = 64,
374 .pref = 64,
375 .idx = 64,
376 };
377 const address_space_info = llvmAddressSpaceInfo(self.target);
378 assert(address_space_info[0].llvm == llvm.address_space.default);
379 for (address_space_info) |info| {
380 const is_default = info.llvm == llvm.address_space.default;
381 if (info.non_integral) {
382 assert(!is_default);
383 any_non_integral = true;
384 }
385 const size = info.size orelse ptr_bit_width;
386 const abi = info.abi orelse ptr_bit_width;
387 const pref = info.pref orelse abi;
388 const idx = info.idx orelse size;
389 const matches_default =
390 size == default_info.size and
391 abi == default_info.abi and
392 pref == default_info.pref and
393 idx == default_info.idx;
394 if (is_default) default_info = .{
395 .size = size,
396 .abi = abi,
397 .pref = pref,
398 .idx = idx,
399 };
400 if (!info.force_in_data_layout and matches_default and
401 self.target.cpu.arch != .riscv64 and !is_aarch64_windows) continue;
402 try writer.writeAll("-p");
403 if (!is_default) try writer.print("{d}", .{info.llvm});
404 try writer.print(":{d}:{d}", .{ size, abi });
405 if (pref != abi or idx != size) {
406 try writer.print(":{d}", .{pref});
407 if (idx != size) try writer.print(":{d}", .{idx});
408 }
409 }
410 if (self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb())
411 try writer.writeAll("-Fi8"); // for thumb interwork
412 try self.typeAlignment(.integer, 8, 8, 8, false, writer);
413 try self.typeAlignment(.integer, 16, 16, 16, false, writer);
414 try self.typeAlignment(.integer, 32, if (is_aarch64_windows) 0 else 32, 32, false, writer);
415 try self.typeAlignment(.integer, 64, 32, 64, false, writer);
416 try self.typeAlignment(.integer, 128, 32, 64, false, writer);
417 if (backendSupportsF16(self.target)) try self.typeAlignment(.float, 16, 16, 16, false, writer);
418 try self.typeAlignment(.float, 32, 32, 32, false, writer);
419 try self.typeAlignment(.float, 64, 64, 64, false, writer);
420 if (backendSupportsF80(self.target)) try self.typeAlignment(.float, 80, 0, 0, false, writer);
421 try self.typeAlignment(.float, 128, 128, 128, false, writer);
422 try self.typeAlignment(.vector, 64, 64, 64, false, writer);
423 try self.typeAlignment(.vector, 128, 128, 128, false, writer);
424 if (self.target.os.tag != .windows) try self.typeAlignment(.aggregate, 0, 0, 64, false, writer);
425 for (@as([]const u24, switch (self.target.cpu.arch) {
426 .aarch64_32,
427 .arm,
428 .armeb,
429 .mips,
430 .mipsel,
431 .powerpc,
432 .powerpcle,
433 .thumb,
434 .thumbeb,
435 .riscv32,
436 => &.{32},
437 .aarch64,
438 .aarch64_be,
439 .mips64,
440 .mips64el,
441 .powerpc64,
442 .powerpc64le,
443 .riscv64,
444 .wasm32,
445 .wasm64,
446 => &.{ 32, 64 },
447 .x86 => &.{ 8, 16, 32 },
448 .x86_64 => &.{ 8, 16, 32, 64 },
449 else => &.{},
450 }), 0..) |natural, index| switch (index) {
451 0 => try writer.print("-n{d}", .{natural}),
452 else => try writer.print(":{d}", .{natural}),
453 };
454 if (self.target.os.tag == .windows) try self.typeAlignment(.aggregate, 0, 0, 64, false, writer);
455 const stack_abi = self.target.stackAlignment() * 8;
456 if (self.target.os.tag == .windows or stack_abi != ptr_bit_width)
457 try writer.print("-S{d}", .{stack_abi});
458 try self.typeAlignment(.vector, 256, 128, 128, true, writer);
459 try self.typeAlignment(.vector, 512, 128, 128, true, writer);
460 if (any_non_integral) {
461 try writer.writeAll("-ni");
462 for (address_space_info) |info| if (info.non_integral)
463 try writer.print(":{d}", .{info.llvm});
464 }
465 }
466
467 fn typeAlignment(
468 self: DataLayoutBuilder,
469 kind: enum { integer, vector, float, aggregate },
470 size: u24,
471 default_abi: u24,
472 default_pref: u24,
473 force_pref: bool,
474 writer: anytype,
475 ) @TypeOf(writer).Error!void {
476 var abi = default_abi;
477 var pref = default_pref;
478 if (kind == .float and size == 80) {
479 abi = 128;
480 pref = 128;
481 }
482 for (@as([]const std.Target.CType, switch (kind) {
483 .integer => &.{ .char, .short, .int, .long, .longlong },
484 .float => &.{ .float, .double, .longdouble },
485 .vector, .aggregate => &.{},
486 })) |cty| {
487 if (self.target.c_type_bit_size(cty) != size) continue;
488 abi = self.target.c_type_alignment(cty) * 8;
489 pref = self.target.c_type_preferred_alignment(cty) * 8;
490 break;
491 }
492 switch (kind) {
493 .integer => {
494 abi = @min(abi, self.target.maxIntAlignment() * 8);
495 switch (self.target.os.tag) {
496 .linux => switch (self.target.cpu.arch) {
497 .aarch64, .aarch64_be, .mips, .mipsel => pref = @max(pref, 32),
498 else => {},
499 },
500 else => {},
501 }
502 switch (self.target.cpu.arch) {
503 .aarch64, .aarch64_be, .riscv64 => switch (size) {
504 128 => {
505 abi = size;
506 pref = size;
507 },
508 else => {},
509 },
510 else => {},
511 }
512 },
513 .vector => if (self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb()) {
514 switch (size) {
515 128 => abi = 64,
516 else => {},
517 }
518 } else if (self.target.cpu.arch.isPPC64()) {
519 abi = size;
520 pref = size;
521 },
522 .float => {},
523 .aggregate => if (self.target.os.tag == .windows or
524 self.target.cpu.arch.isARM() or self.target.cpu.arch.isThumb())
525 {
526 pref = @min(pref, self.target.ptrBitWidth());
527 },
528 }
529 if (abi == default_abi and pref == default_pref) return;
530 try writer.print("-{c}", .{@tagName(kind)[0]});
531 if (size != 0) try writer.print("{d}", .{size});
532 try writer.print(":{d}", .{abi});
533 if (pref != abi or force_pref) try writer.print(":{d}", .{pref});
534 }
535};
536
331/// TODO can this be done with simpler logic / different API binding?537/// TODO can this be done with simpler logic / different API binding?
332fn deleteLlvmGlobal(llvm_global: *llvm.Value) void {538fn deleteLlvmGlobal(llvm_global: *llvm.Value) void {
333 if (llvm_global.globalGetValueType().getTypeKind() == .Function) {539 if (llvm_global.globalGetValueType().getTypeKind() == .Function) {
...@@ -530,12 +736,17 @@ pub const Object = struct {...@@ -530,12 +736,17 @@ pub const Object = struct {
530 try builder.init();736 try builder.init();
531 errdefer builder.deinit();737 errdefer builder.deinit();
532 builder.source_filename = try builder.string(options.root_name);738 builder.source_filename = try builder.string(options.root_name);
533 builder.data_layout = rep: {739 builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = options.target }});
740 builder.target_triple = try builder.string(llvm_target_triple);
741
742 if (std.debug.runtime_safety) {
534 const rep = target_data.stringRep();743 const rep = target_data.stringRep();
535 defer llvm.disposeMessage(rep);744 defer llvm.disposeMessage(rep);
536 break :rep try builder.string(std.mem.span(rep));745 std.testing.expectEqualStrings(
537 };746 std.mem.span(rep),
538 builder.target_triple = try builder.string(llvm_target_triple);747 builder.data_layout.toSlice(&builder).?,
748 ) catch unreachable;
749 }
539750
540 return Object{751 return Object{
541 .gpa = gpa,752 .gpa = gpa,
...@@ -768,6 +979,10 @@ pub const Object = struct {...@@ -768,6 +979,10 @@ pub const Object = struct {
768 if (comp.verbose_llvm_ir) |path| {979 if (comp.verbose_llvm_ir) |path| {
769 if (std.mem.eql(u8, path, "-")) {980 if (std.mem.eql(u8, path, "-")) {
770 self.llvm_module.dump();981 self.llvm_module.dump();
982
983 const writer = std.io.getStdErr().writer();
984 try writer.writeAll("\n" ++ "-" ** 200 ++ "\n\n");
985 try self.builder.dump(writer);
771 } else {986 } else {
772 const path_z = try comp.gpa.dupeZ(u8, path);987 const path_z = try comp.gpa.dupeZ(u8, path);
773 defer comp.gpa.free(path_z);988 defer comp.gpa.free(path_z);
...@@ -836,12 +1051,6 @@ pub const Object = struct {...@@ -836,12 +1051,6 @@ pub const Object = struct {
836 emit_asm_msg, emit_bin_msg, emit_llvm_ir_msg, emit_llvm_bc_msg,1051 emit_asm_msg, emit_bin_msg, emit_llvm_ir_msg, emit_llvm_bc_msg,
837 });1052 });
8381053
839 {
840 const writer = std.io.getStdErr().writer();
841 try writer.writeAll("\n" ++ "-" ** 200 ++ "\n\n");
842 try self.builder.dump(writer);
843 }
844
845 // Unfortunately, LLVM shits the bed when we ask for both binary and assembly.1054 // Unfortunately, LLVM shits the bed when we ask for both binary and assembly.
846 // So we call the entire pipeline multiple times if this is requested.1055 // So we call the entire pipeline multiple times if this is requested.
847 var error_message: [*:0]const u8 = undefined;1056 var error_message: [*:0]const u8 = undefined;
...@@ -1311,7 +1520,7 @@ pub const Object = struct {...@@ -1311,7 +1520,7 @@ pub const Object = struct {
1311 try global_index.rename(&self.builder, decl_name);1520 try global_index.rename(&self.builder, decl_name);
1312 const decl_name_slice = decl_name.toSlice(&self.builder).?;1521 const decl_name_slice = decl_name.toSlice(&self.builder).?;
1313 const global = global_index.ptr(&self.builder);1522 const global = global_index.ptr(&self.builder);
1314 global.unnamed_addr = .none;1523 global.unnamed_addr = .default;
1315 llvm_global.setUnnamedAddr(.False);1524 llvm_global.setUnnamedAddr(.False);
1316 global.linkage = .external;1525 global.linkage = .external;
1317 llvm_global.setLinkage(.External);1526 llvm_global.setLinkage(.External);
...@@ -2674,11 +2883,15 @@ pub const Object = struct {...@@ -2674,11 +2883,15 @@ pub const Object = struct {
26742883
2675 const target = mod.getTarget();2884 const target = mod.getTarget();
26762885
2677 const llvm_type = try o.lowerLlvmType(decl.ty);2886 const ty = try o.lowerType(decl.ty);
2887 const llvm_type = if (ty != .none)
2888 o.builder.llvm_types.items[@intFromEnum(ty)]
2889 else
2890 try o.lowerLlvmType(decl.ty);
2678 const llvm_actual_addrspace = toLlvmGlobalAddressSpace(decl.@"addrspace", target);2891 const llvm_actual_addrspace = toLlvmGlobalAddressSpace(decl.@"addrspace", target);
26792892
2680 var global = Builder.Global{2893 var global = Builder.Global{
2681 .type = .void,2894 .type = if (ty != .none) ty else .void,
2682 .kind = .{ .object = @enumFromInt(o.builder.objects.items.len) },2895 .kind = .{ .object = @enumFromInt(o.builder.objects.items.len) },
2683 };2896 };
2684 var object = Builder.Object{2897 var object = Builder.Object{
...@@ -2698,7 +2911,7 @@ pub const Object = struct {...@@ -2698,7 +2911,7 @@ pub const Object = struct {
26982911
2699 // This is needed for declarations created by `@extern`.2912 // This is needed for declarations created by `@extern`.
2700 if (is_extern) {2913 if (is_extern) {
2701 global.unnamed_addr = .none;2914 global.unnamed_addr = .default;
2702 llvm_global.setUnnamedAddr(.False);2915 llvm_global.setUnnamedAddr(.False);
2703 global.linkage = .external;2916 global.linkage = .external;
2704 llvm_global.setLinkage(.External);2917 llvm_global.setLinkage(.External);
...@@ -2708,7 +2921,7 @@ pub const Object = struct {...@@ -2708,7 +2921,7 @@ pub const Object = struct {
2708 object.thread_local = .generaldynamic;2921 object.thread_local = .generaldynamic;
2709 llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);2922 llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
2710 } else {2923 } else {
2711 object.thread_local = .none;2924 object.thread_local = .default;
2712 llvm_global.setThreadLocalMode(.NotThreadLocal);2925 llvm_global.setThreadLocalMode(.NotThreadLocal);
2713 }2926 }
2714 if (variable.is_weak_linkage) {2927 if (variable.is_weak_linkage) {
...@@ -2962,9 +3175,9 @@ pub const Object = struct {...@@ -2962,9 +3175,9 @@ pub const Object = struct {
2962 const name = try o.builder.string(mod.intern_pool.stringToSlice(3175 const name = try o.builder.string(mod.intern_pool.stringToSlice(
2963 try struct_obj.getFullyQualifiedName(mod),3176 try struct_obj.getFullyQualifiedName(mod),
2964 ));3177 ));
2965 _ = try o.builder.opaqueType(name);3178 const ty = try o.builder.opaqueType(name);
29663179
2967 const llvm_struct_ty = o.context.structCreateNamed(name.toSlice(&o.builder).?);3180 const llvm_struct_ty = o.builder.llvm_types.items[@intFromEnum(ty)];
2968 gop.value_ptr.* = llvm_struct_ty; // must be done before any recursive calls3181 gop.value_ptr.* = llvm_struct_ty; // must be done before any recursive calls
29693182
2970 assert(struct_obj.haveFieldTypes());3183 assert(struct_obj.haveFieldTypes());
...@@ -3101,16 +3314,6 @@ pub const Object = struct {...@@ -3101,16 +3314,6 @@ pub const Object = struct {
3101 }3314 }
3102 }3315 }
31033316
3104 fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
3105 const mod = o.module;
3106 switch (t.toIntern()) {
3107 .void_type, .noreturn_type => return .void,
3108 else => switch (mod.intern_pool.indexToKey(t.toIntern())) {
3109 else => return .none,
3110 },
3111 }
3112 }
3113
3114 fn lowerLlvmTypeFn(o: *Object, fn_ty: Type) Allocator.Error!*llvm.Type {3317 fn lowerLlvmTypeFn(o: *Object, fn_ty: Type) Allocator.Error!*llvm.Type {
3115 const mod = o.module;3318 const mod = o.module;
3116 const ip = &mod.intern_pool;3319 const ip = &mod.intern_pool;
...@@ -3206,6 +3409,149 @@ pub const Object = struct {...@@ -3206,6 +3409,149 @@ pub const Object = struct {
3206 return llvm_elem_ty;3409 return llvm_elem_ty;
3207 }3410 }
32083411
3412 fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
3413 const mod = o.module;
3414 const target = mod.getTarget();
3415 return switch (t.toIntern()) {
3416 .u0_type, .i0_type => unreachable,
3417 inline .u1_type,
3418 .u8_type,
3419 .i8_type,
3420 .u16_type,
3421 .i16_type,
3422 .u29_type,
3423 .u32_type,
3424 .i32_type,
3425 .u64_type,
3426 .i64_type,
3427 .u80_type,
3428 .u128_type,
3429 .i128_type,
3430 => |tag| @field(Builder.Type, "i" ++ @tagName(tag)[1 .. @tagName(tag).len - "_type".len]),
3431 .usize_type, .isize_type => try o.builder.intType(target.ptrBitWidth()),
3432 inline .c_char_type,
3433 .c_short_type,
3434 .c_ushort_type,
3435 .c_int_type,
3436 .c_uint_type,
3437 .c_long_type,
3438 .c_ulong_type,
3439 .c_longlong_type,
3440 .c_ulonglong_type,
3441 => |tag| try o.builder.intType(target.c_type_bit_size(
3442 @field(std.Target.CType, @tagName(tag)["c_".len .. @tagName(tag).len - "_type".len]),
3443 )),
3444 .c_longdouble_type,
3445 .f16_type,
3446 .f32_type,
3447 .f64_type,
3448 .f80_type,
3449 .f128_type,
3450 => switch (t.floatBits(target)) {
3451 16 => if (backendSupportsF16(target)) .half else .i16,
3452 32 => .float,
3453 64 => .double,
3454 80 => if (backendSupportsF80(target)) .x86_fp80 else .i80,
3455 128 => .fp128,
3456 else => unreachable,
3457 },
3458 .anyopaque_type => unreachable,
3459 .bool_type => .i1,
3460 .void_type => .void,
3461 .type_type => unreachable,
3462 .anyerror_type => .i16,
3463 .comptime_int_type, .comptime_float_type, .noreturn_type => unreachable,
3464 .anyframe_type => @panic("TODO implement lowerType for AnyFrame types"),
3465 .null_type,
3466 .undefined_type,
3467 .enum_literal_type,
3468 .atomic_order_type,
3469 .atomic_rmw_op_type,
3470 .calling_convention_type,
3471 .address_space_type,
3472 .float_mode_type,
3473 .reduce_op_type,
3474 .call_modifier_type,
3475 .prefetch_options_type,
3476 .export_options_type,
3477 .extern_options_type,
3478 .type_info_type,
3479 => unreachable,
3480 .manyptr_u8_type,
3481 .manyptr_const_u8_type,
3482 .manyptr_const_u8_sentinel_0_type,
3483 .single_const_pointer_to_comptime_int_type,
3484 => .ptr,
3485 .slice_const_u8_type, .slice_const_u8_sentinel_0_type => .none,
3486 .optional_noreturn_type => unreachable,
3487 .anyerror_void_error_union_type => .i16,
3488 .generic_poison_type, .empty_struct_type => unreachable,
3489 // values, not types
3490 .undef,
3491 .zero,
3492 .zero_usize,
3493 .zero_u8,
3494 .one,
3495 .one_usize,
3496 .one_u8,
3497 .four_u8,
3498 .negative_one,
3499 .calling_convention_c,
3500 .calling_convention_inline,
3501 .void_value,
3502 .unreachable_value,
3503 .null_value,
3504 .bool_true,
3505 .bool_false,
3506 .empty_struct,
3507 .generic_poison,
3508 .var_args_param_type,
3509 .none,
3510 => unreachable,
3511 else => switch (mod.intern_pool.indexToKey(t.toIntern())) {
3512 .int_type => |int_type| try o.builder.intType(int_type.bits),
3513 .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
3514 .One, .Many, .C => try o.builder.pointerType(@enumFromInt(
3515 toLlvmAddressSpace(ptr_type.flags.address_space, target),
3516 )),
3517 .Slice => .none,
3518 },
3519 .array_type, .vector_type, .opt_type => .none,
3520 .anyframe_type => @panic("TODO implement lowerType for AnyFrame types"),
3521 .error_union_type => .none,
3522 .simple_type => unreachable,
3523 .struct_type,
3524 .anon_struct_type,
3525 .union_type,
3526 .opaque_type,
3527 => .none,
3528 .enum_type => |enum_type| try o.lowerType(enum_type.tag_ty.toType()),
3529 .func_type, .error_set_type, .inferred_error_set_type => .none,
3530 // values, not types
3531 .undef,
3532 .runtime_value,
3533 .simple_value,
3534 .variable,
3535 .extern_func,
3536 .func,
3537 .int,
3538 .err,
3539 .error_union,
3540 .enum_literal,
3541 .enum_tag,
3542 .empty_enum_value,
3543 .float,
3544 .ptr,
3545 .opt,
3546 .aggregate,
3547 .un,
3548 // memoization, not types
3549 .memoized_call,
3550 => unreachable,
3551 },
3552 };
3553 }
3554
3209 fn lowerValue(o: *Object, arg_tv: TypedValue) Error!*llvm.Value {3555 fn lowerValue(o: *Object, arg_tv: TypedValue) Error!*llvm.Value {
3210 const mod = o.module;3556 const mod = o.module;
3211 const gpa = o.gpa;3557 const gpa = o.gpa;
...@@ -10606,44 +10952,63 @@ fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) llvm.Ca...@@ -10606,44 +10952,63 @@ fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) llvm.Ca
1060610952
10607/// Convert a zig-address space to an llvm address space.10953/// Convert a zig-address space to an llvm address space.
10608fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: std.Target) c_uint {10954fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: std.Target) c_uint {
10955 for (llvmAddressSpaceInfo(target)) |info| if (info.zig == address_space) return info.llvm;
10956 unreachable;
10957}
10958
10959const AddressSpaceInfo = struct {
10960 zig: ?std.builtin.AddressSpace,
10961 llvm: c_uint,
10962 non_integral: bool = false,
10963 size: ?u16 = null,
10964 abi: ?u16 = null,
10965 pref: ?u16 = null,
10966 idx: ?u16 = null,
10967 force_in_data_layout: bool = false,
10968};
10969fn llvmAddressSpaceInfo(target: std.Target) []const AddressSpaceInfo {
10609 return switch (target.cpu.arch) {10970 return switch (target.cpu.arch) {
10610 .x86, .x86_64 => switch (address_space) {10971 .x86, .x86_64 => &.{
10611 .generic => llvm.address_space.default,10972 .{ .zig = .generic, .llvm = llvm.address_space.default },
10612 .gs => llvm.address_space.x86.gs,10973 .{ .zig = .gs, .llvm = llvm.address_space.x86.gs },
10613 .fs => llvm.address_space.x86.fs,10974 .{ .zig = .fs, .llvm = llvm.address_space.x86.fs },
10614 .ss => llvm.address_space.x86.ss,10975 .{ .zig = .ss, .llvm = llvm.address_space.x86.ss },
10615 else => unreachable,10976 .{ .zig = null, .llvm = llvm.address_space.x86.ptr32_sptr, .size = 32, .abi = 32, .force_in_data_layout = true },
10977 .{ .zig = null, .llvm = llvm.address_space.x86.ptr32_uptr, .size = 32, .abi = 32, .force_in_data_layout = true },
10978 .{ .zig = null, .llvm = llvm.address_space.x86.ptr64, .size = 64, .abi = 64, .force_in_data_layout = true },
10616 },10979 },
10617 .nvptx, .nvptx64 => switch (address_space) {10980 .nvptx, .nvptx64 => &.{
10618 .generic => llvm.address_space.default,10981 .{ .zig = .generic, .llvm = llvm.address_space.default },
10619 .global => llvm.address_space.nvptx.global,10982 .{ .zig = .global, .llvm = llvm.address_space.nvptx.global },
10620 .constant => llvm.address_space.nvptx.constant,10983 .{ .zig = .constant, .llvm = llvm.address_space.nvptx.constant },
10621 .param => llvm.address_space.nvptx.param,10984 .{ .zig = .param, .llvm = llvm.address_space.nvptx.param },
10622 .shared => llvm.address_space.nvptx.shared,10985 .{ .zig = .shared, .llvm = llvm.address_space.nvptx.shared },
10623 .local => llvm.address_space.nvptx.local,10986 .{ .zig = .local, .llvm = llvm.address_space.nvptx.local },
10624 else => unreachable,
10625 },10987 },
10626 .amdgcn => switch (address_space) {10988 .amdgcn => &.{
10627 .generic => llvm.address_space.amdgpu.flat,10989 .{ .zig = .generic, .llvm = llvm.address_space.amdgpu.flat },
10628 .global => llvm.address_space.amdgpu.global,10990 .{ .zig = .global, .llvm = llvm.address_space.amdgpu.global },
10629 .constant => llvm.address_space.amdgpu.constant,10991 .{ .zig = .constant, .llvm = llvm.address_space.amdgpu.constant },
10630 .shared => llvm.address_space.amdgpu.local,10992 .{ .zig = .shared, .llvm = llvm.address_space.amdgpu.local },
10631 .local => llvm.address_space.amdgpu.private,10993 .{ .zig = .local, .llvm = llvm.address_space.amdgpu.private },
10632 else => unreachable,
10633 },10994 },
10634 .avr => switch (address_space) {10995 .avr => &.{
10635 .generic => llvm.address_space.default,10996 .{ .zig = .generic, .llvm = llvm.address_space.default },
10636 .flash => llvm.address_space.avr.flash,10997 .{ .zig = .flash, .llvm = llvm.address_space.avr.flash },
10637 .flash1 => llvm.address_space.avr.flash1,10998 .{ .zig = .flash1, .llvm = llvm.address_space.avr.flash1 },
10638 .flash2 => llvm.address_space.avr.flash2,10999 .{ .zig = .flash2, .llvm = llvm.address_space.avr.flash2 },
10639 .flash3 => llvm.address_space.avr.flash3,11000 .{ .zig = .flash3, .llvm = llvm.address_space.avr.flash3 },
10640 .flash4 => llvm.address_space.avr.flash4,11001 .{ .zig = .flash4, .llvm = llvm.address_space.avr.flash4 },
10641 .flash5 => llvm.address_space.avr.flash5,11002 .{ .zig = .flash5, .llvm = llvm.address_space.avr.flash5 },
10642 else => unreachable,
10643 },11003 },
10644 else => switch (address_space) {11004 .wasm32, .wasm64 => &.{
10645 .generic => llvm.address_space.default,11005 .{ .zig = .generic, .llvm = llvm.address_space.default },
10646 else => unreachable,11006 .{ .zig = null, .llvm = llvm.address_space.wasm.variable, .non_integral = true },
11007 .{ .zig = null, .llvm = llvm.address_space.wasm.externref, .non_integral = true, .size = 8, .abi = 8 },
11008 .{ .zig = null, .llvm = llvm.address_space.wasm.funcref, .non_integral = true, .size = 8, .abi = 8 },
11009 },
11010 else => &.{
11011 .{ .zig = .generic, .llvm = llvm.address_space.default },
10647 },11012 },
10648 };11013 };
10649}11014}
src/codegen/llvm/Builder.zig+64-42
...@@ -17,6 +17,7 @@ string_indices: std.ArrayListUnmanaged(u32) = .{},...@@ -17,6 +17,7 @@ string_indices: std.ArrayListUnmanaged(u32) = .{},
1717
18types: std.AutoArrayHashMapUnmanaged(String, Type) = .{},18types: std.AutoArrayHashMapUnmanaged(String, Type) = .{},
19next_unnamed_type: String = @enumFromInt(0),19next_unnamed_type: String = @enumFromInt(0),
20next_unique_type_id: std.AutoHashMapUnmanaged(String, u32) = .{},
20type_map: std.AutoArrayHashMapUnmanaged(void, void) = .{},21type_map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
21type_data: std.ArrayListUnmanaged(Type.Data) = .{},22type_data: std.ArrayListUnmanaged(Type.Data) = .{},
22type_extra: std.ArrayListUnmanaged(u32) = .{},23type_extra: std.ArrayListUnmanaged(u32) = .{},
...@@ -109,8 +110,10 @@ pub const Type = enum(u32) {...@@ -109,8 +110,10 @@ pub const Type = enum(u32) {
109 i1,110 i1,
110 i8,111 i8,
111 i16,112 i16,
113 i29,
112 i32,114 i32,
113 i64,115 i64,
116 i80,
114 i128,117 i128,
115 ptr,118 ptr,
116119
...@@ -173,17 +176,18 @@ pub const Type = enum(u32) {...@@ -173,17 +176,18 @@ pub const Type = enum(u32) {
173 if (std.enums.tagName(Type, data.type)) |name| return writer.writeAll(name);176 if (std.enums.tagName(Type, data.type)) |name| return writer.writeAll(name);
174 const type_data = data.builder.type_data.items[@intFromEnum(data.type)];177 const type_data = data.builder.type_data.items[@intFromEnum(data.type)];
175 switch (type_data.tag) {178 switch (type_data.tag) {
179 .integer => try writer.print("i{d}", .{type_data.data}),
176 .named_structure => {180 .named_structure => {
177 const extra = data.builder.typeExtraData(NamedStructure, type_data.data);181 const extra = data.builder.typeExtraData(NamedStructure, type_data.data);
178 if (comptime std.mem.eql(u8, fmt_str, "")) try writer.print("%{}", .{182 if (comptime std.mem.eql(u8, fmt_str, "")) switch (extra.child) {
179 extra.id.fmt(data.builder),
180 }) else if (comptime std.mem.eql(u8, fmt_str, "+")) switch (extra.child) {
181 .none => try writer.writeAll("opaque"),183 .none => try writer.writeAll("opaque"),
182 else => try format(.{184 else => try format(.{
183 .type = extra.child,185 .type = extra.child,
184 .builder = data.builder,186 .builder = data.builder,
185 }, fmt_str, fmt_opts, writer),187 }, fmt_str, fmt_opts, writer),
186 } else @compileError("invalid format string: '" ++ fmt_str ++ "'");188 } else if (comptime std.mem.eql(u8, fmt_str, "%")) try writer.print("%{}", .{
189 extra.id.fmt(data.builder),
190 }) else @compileError("invalid format string: '" ++ fmt_str ++ "'");
187 },191 },
188 else => try writer.print("<type 0x{X}>", .{@intFromEnum(data.type)}),192 else => try writer.print("<type 0x{X}>", .{@intFromEnum(data.type)}),
189 }193 }
...@@ -220,7 +224,7 @@ pub const Linkage = enum {...@@ -220,7 +224,7 @@ pub const Linkage = enum {
220};224};
221225
222pub const Preemption = enum {226pub const Preemption = enum {
223 none,227 default,
224 dso_preemptable,228 dso_preemptable,
225 dso_local,229 dso_local,
226230
...@@ -230,7 +234,7 @@ pub const Preemption = enum {...@@ -230,7 +234,7 @@ pub const Preemption = enum {
230 _: std.fmt.FormatOptions,234 _: std.fmt.FormatOptions,
231 writer: anytype,235 writer: anytype,
232 ) @TypeOf(writer).Error!void {236 ) @TypeOf(writer).Error!void {
233 if (self == .none) return;237 if (self == .default) return;
234 try writer.writeAll(@tagName(self));238 try writer.writeAll(@tagName(self));
235 try writer.writeByte(' ');239 try writer.writeByte(' ');
236 }240 }
...@@ -271,7 +275,7 @@ pub const DllStorageClass = enum {...@@ -271,7 +275,7 @@ pub const DllStorageClass = enum {
271};275};
272276
273pub const ThreadLocal = enum {277pub const ThreadLocal = enum {
274 none,278 default,
275 generaldynamic,279 generaldynamic,
276 localdynamic,280 localdynamic,
277 initialexec,281 initialexec,
...@@ -283,7 +287,7 @@ pub const ThreadLocal = enum {...@@ -283,7 +287,7 @@ pub const ThreadLocal = enum {
283 _: std.fmt.FormatOptions,287 _: std.fmt.FormatOptions,
284 writer: anytype,288 writer: anytype,
285 ) @TypeOf(writer).Error!void {289 ) @TypeOf(writer).Error!void {
286 if (self == .none) return;290 if (self == .default) return;
287 try writer.writeAll("thread_local");291 try writer.writeAll("thread_local");
288 if (self != .generaldynamic) {292 if (self != .generaldynamic) {
289 try writer.writeByte('(');293 try writer.writeByte('(');
...@@ -295,7 +299,7 @@ pub const ThreadLocal = enum {...@@ -295,7 +299,7 @@ pub const ThreadLocal = enum {
295};299};
296300
297pub const UnnamedAddr = enum {301pub const UnnamedAddr = enum {
298 none,302 default,
299 unnamed_addr,303 unnamed_addr,
300 local_unnamed_addr,304 local_unnamed_addr,
301305
...@@ -305,14 +309,14 @@ pub const UnnamedAddr = enum {...@@ -305,14 +309,14 @@ pub const UnnamedAddr = enum {
305 _: std.fmt.FormatOptions,309 _: std.fmt.FormatOptions,
306 writer: anytype,310 writer: anytype,
307 ) @TypeOf(writer).Error!void {311 ) @TypeOf(writer).Error!void {
308 if (self == .none) return;312 if (self == .default) return;
309 try writer.writeAll(@tagName(self));313 try writer.writeAll(@tagName(self));
310 try writer.writeByte(' ');314 try writer.writeByte(' ');
311 }315 }
312};316};
313317
314pub const AddrSpace = enum(u24) {318pub const AddrSpace = enum(u24) {
315 none,319 default,
316 _,320 _,
317321
318 pub fn format(322 pub fn format(
...@@ -321,13 +325,13 @@ pub const AddrSpace = enum(u24) {...@@ -321,13 +325,13 @@ pub const AddrSpace = enum(u24) {
321 _: std.fmt.FormatOptions,325 _: std.fmt.FormatOptions,
322 writer: anytype,326 writer: anytype,
323 ) @TypeOf(writer).Error!void {327 ) @TypeOf(writer).Error!void {
324 if (self == .none) return;328 if (self == .default) return;
325 try writer.print("addrspace({d}) ", .{@intFromEnum(self)});329 try writer.print("addrspace({d}) ", .{@intFromEnum(self)});
326 }330 }
327};331};
328332
329pub const ExternallyInitialized = enum {333pub const ExternallyInitialized = enum {
330 none,334 default,
331 externally_initialized,335 externally_initialized,
332336
333 pub fn format(337 pub fn format(
...@@ -336,7 +340,7 @@ pub const ExternallyInitialized = enum {...@@ -336,7 +340,7 @@ pub const ExternallyInitialized = enum {
336 _: std.fmt.FormatOptions,340 _: std.fmt.FormatOptions,
337 writer: anytype,341 writer: anytype,
338 ) @TypeOf(writer).Error!void {342 ) @TypeOf(writer).Error!void {
339 if (self == .none) return;343 if (self == .default) return;
340 try writer.writeAll(@tagName(self));344 try writer.writeAll(@tagName(self));
341 try writer.writeByte(' ');345 try writer.writeByte(' ');
342 }346 }
...@@ -369,12 +373,12 @@ pub const Alignment = enum(u6) {...@@ -369,12 +373,12 @@ pub const Alignment = enum(u6) {
369373
370pub const Global = struct {374pub const Global = struct {
371 linkage: Linkage = .default,375 linkage: Linkage = .default,
372 preemption: Preemption = .none,376 preemption: Preemption = .default,
373 visibility: Visibility = .default,377 visibility: Visibility = .default,
374 dll_storage_class: DllStorageClass = .default,378 dll_storage_class: DllStorageClass = .default,
375 unnamed_addr: UnnamedAddr = .none,379 unnamed_addr: UnnamedAddr = .default,
376 addr_space: AddrSpace = .none,380 addr_space: AddrSpace = .default,
377 externally_initialized: ExternallyInitialized = .none,381 externally_initialized: ExternallyInitialized = .default,
378 type: Type,382 type: Type,
379 alignment: Alignment = .default,383 alignment: Alignment = .default,
380 kind: union(enum) {384 kind: union(enum) {
...@@ -459,7 +463,7 @@ pub const Alias = struct {...@@ -459,7 +463,7 @@ pub const Alias = struct {
459463
460pub const Object = struct {464pub const Object = struct {
461 global: Global.Index,465 global: Global.Index,
462 thread_local: ThreadLocal = .none,466 thread_local: ThreadLocal = .default,
463 mutability: enum { global, constant } = .global,467 mutability: enum { global, constant } = .global,
464 init: void = {},468 init: void = {},
465469
...@@ -525,7 +529,7 @@ pub fn init(self: *Builder) Allocator.Error!void {...@@ -525,7 +529,7 @@ pub fn init(self: *Builder) Allocator.Error!void {
525 @field(llvm.Context, simple_field.name ++ "Type")(self.llvm_context),529 @field(llvm.Context, simple_field.name ++ "Type")(self.llvm_context),
526 );530 );
527 }531 }
528 inline for (.{ 1, 8, 16, 32, 64, 128 }) |bits| assert(self.intTypeAssumeCapacity(bits) ==532 inline for (.{ 1, 8, 16, 29, 32, 64, 80, 128 }) |bits| assert(self.intTypeAssumeCapacity(bits) ==
529 @field(Type, std.fmt.comptimePrint("i{d}", .{bits})));533 @field(Type, std.fmt.comptimePrint("i{d}", .{bits})));
530 inline for (.{0}) |addr_space|534 inline for (.{0}) |addr_space|
531 assert(self.pointerTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);535 assert(self.pointerTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);
...@@ -541,6 +545,7 @@ pub fn deinit(self: *Builder) void {...@@ -541,6 +545,7 @@ pub fn deinit(self: *Builder) void {
541 self.string_indices.deinit(self.gpa);545 self.string_indices.deinit(self.gpa);
542546
543 self.types.deinit(self.gpa);547 self.types.deinit(self.gpa);
548 self.next_unique_type_id.deinit(self.gpa);
544 self.type_map.deinit(self.gpa);549 self.type_map.deinit(self.gpa);
545 self.type_data.deinit(self.gpa);550 self.type_data.deinit(self.gpa);
546 self.type_extra.deinit(self.gpa);551 self.type_extra.deinit(self.gpa);
...@@ -596,13 +601,18 @@ pub fn fmtAssumeCapacity(self: *Builder, comptime fmt_str: []const u8, fmt_args:...@@ -596,13 +601,18 @@ pub fn fmtAssumeCapacity(self: *Builder, comptime fmt_str: []const u8, fmt_args:
596}601}
597602
598pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {603pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
604 try self.string_map.ensureUnusedCapacity(self.gpa, 1);
605 try self.string_bytes.ensureUnusedCapacity(self.gpa, name.toSlice(self).?.len +
606 comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)}));
607 try self.string_indices.ensureUnusedCapacity(self.gpa, 1);
599 try self.types.ensureUnusedCapacity(self.gpa, 1);608 try self.types.ensureUnusedCapacity(self.gpa, 1);
609 try self.next_unique_type_id.ensureUnusedCapacity(self.gpa, 1);
600 try self.ensureUnusedCapacityTypes(1, Type.NamedStructure);610 try self.ensureUnusedCapacityTypes(1, Type.NamedStructure);
601 return self.opaqueTypeAssumeCapacity(name);611 return self.opaqueTypeAssumeCapacity(name);
602}612}
603613
604pub fn intType(self: *Builder, bits: u24) Allocator.Error!Type {614pub fn intType(self: *Builder, bits: u24) Allocator.Error!Type {
605 try self.ensureUnusedCapacityTypes(1);615 try self.ensureUnusedCapacityTypes(1, null);
606 return self.intTypeAssumeCapacity(bits);616 return self.intTypeAssumeCapacity(bits);
607}617}
608618
...@@ -695,27 +705,39 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {...@@ -695,27 +705,39 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
695 lhs == ctx.builder.typeExtraData(Type.NamedStructure, rhs_data.data).id;705 lhs == ctx.builder.typeExtraData(Type.NamedStructure, rhs_data.data).id;
696 }706 }
697 };707 };
698 const id = if (name == .none) name: {708 var id = name;
699 const next_name = self.next_unnamed_type;709 if (name == .none) {
700 assert(next_name != .none);710 id = self.next_unnamed_type;
701 self.next_unnamed_type = @enumFromInt(@intFromEnum(next_name) + 1);711 assert(id != .none);
702 break :name next_name;712 self.next_unnamed_type = @enumFromInt(@intFromEnum(id) + 1);
703 } else name: {713 } else assert(name.toIndex() != null);
704 assert(name.toIndex() != null);714 while (true) {
705 break :name name;715 const type_gop = self.types.getOrPutAssumeCapacity(id);
706 };716 if (!type_gop.found_existing) {
707 const gop = self.type_map.getOrPutAssumeCapacityAdapted(id, Adapter{ .builder = self });717 const gop = self.type_map.getOrPutAssumeCapacityAdapted(id, Adapter{ .builder = self });
708 if (!gop.found_existing) {718 assert(!gop.found_existing);
709 gop.key_ptr.* = {};719 gop.key_ptr.* = {};
710 gop.value_ptr.* = {};720 gop.value_ptr.* = {};
711 self.type_data.appendAssumeCapacity(.{721 self.type_data.appendAssumeCapacity(.{
712 .tag = .named_structure,722 .tag = .named_structure,
713 .data = self.addTypeExtraAssumeCapacity(Type.NamedStructure{ .id = id, .child = .none }),723 .data = self.addTypeExtraAssumeCapacity(Type.NamedStructure{
714 });724 .id = id,
725 .child = .none,
726 }),
727 });
728 const result: Type = @enumFromInt(gop.index);
729 type_gop.value_ptr.* = result;
730 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
731 self.llvm_context.structCreateNamed(id.toSlice(self) orelse ""),
732 );
733 return result;
734 }
735
736 const unique_gop = self.next_unique_type_id.getOrPutAssumeCapacity(name);
737 if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;
738 id = self.fmtAssumeCapacity("{s}.{d}", .{ name.toSlice(self).?, unique_gop.value_ptr.* });
739 unique_gop.value_ptr.* += 1;
715 }740 }
716 const result: Type = @enumFromInt(gop.index);
717 self.types.putAssumeCapacityNoClobber(id, result);
718 return result;
719}741}
720742
721fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type {743fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type {
...@@ -786,7 +808,7 @@ pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {...@@ -786,7 +808,7 @@ pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {
786 , .{self.target_triple.fmt(self)});808 , .{self.target_triple.fmt(self)});
787 try writer.writeByte('\n');809 try writer.writeByte('\n');
788 for (self.types.keys(), self.types.values()) |id, ty| try writer.print(810 for (self.types.keys(), self.types.values()) |id, ty| try writer.print(
789 \\%{} = type {+}811 \\%{} = type {}
790 \\812 \\
791 , .{ id.fmt(self), ty.fmt(self) });813 , .{ id.fmt(self), ty.fmt(self) });
792 try writer.writeByte('\n');814 try writer.writeByte('\n');
src/codegen/llvm/bindings.zig+7
...@@ -1612,6 +1612,13 @@ pub const address_space = struct {...@@ -1612,6 +1612,13 @@ pub const address_space = struct {
1612 pub const constant_buffer_14: c_uint = 22;1612 pub const constant_buffer_14: c_uint = 22;
1613 pub const constant_buffer_15: c_uint = 23;1613 pub const constant_buffer_15: c_uint = 23;
1614 };1614 };
1615
1616 // See llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.h
1617 pub const wasm = struct {
1618 pub const variable = 1;
1619 pub const externref = 10;
1620 pub const funcref = 20;
1621 };
1615};1622};
16161623
1617pub const DIEnumerator = opaque {};1624pub const DIEnumerator = opaque {};