From b4bb64ce78bf2dee9437f366a362ef4d8c77b204 Mon Sep 17 00:00:00 2001 From: David Rubin Date: Sun, 11 Aug 2024 03:14:12 -0700 Subject: sema: rework type resolution to use Zcu when possible --- src/codegen.zig | 117 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 59 insertions(+), 58 deletions(-) (limited to 'src/codegen.zig') diff --git a/src/codegen.zig b/src/codegen.zig index 0c592c6f19..6b69e6a539 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -198,17 +198,17 @@ pub fn generateSymbol( const tracy = trace(@src()); defer tracy.end(); - const mod = pt.zcu; - const ip = &mod.intern_pool; - const ty = val.typeOf(mod); + const zcu = pt.zcu; + const ip = &zcu.intern_pool; + const ty = val.typeOf(zcu); - const target = mod.getTarget(); + const target = zcu.getTarget(); const endian = target.cpu.arch.endian(); log.debug("generateSymbol: val = {}", .{val.fmtValue(pt)}); - if (val.isUndefDeep(mod)) { - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + if (val.isUndefDeep(zcu)) { + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; try code.appendNTimes(0xaa, abi_size); return .ok; } @@ -254,9 +254,9 @@ pub fn generateSymbol( .empty_enum_value, => unreachable, // non-runtime values .int => { - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; var space: Value.BigIntSpace = undefined; - const int_val = val.toBigInt(&space, pt); + const int_val = val.toBigInt(&space, zcu); int_val.writeTwosComplement(try code.addManyAsSlice(abi_size), endian); }, .err => |err| { @@ -264,20 +264,20 @@ pub fn generateSymbol( try code.writer().writeInt(u16, @intCast(int), endian); }, .error_union => |error_union| { - const payload_ty = ty.errorUnionPayload(mod); + const payload_ty = ty.errorUnionPayload(zcu); const err_val: u16 = switch (error_union.val) { .err_name => |err_name| @intCast(try pt.getErrorValue(err_name)), .payload => 0, }; - if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) { + if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) { try code.writer().writeInt(u16, err_val, endian); return .ok; } - const payload_align = payload_ty.abiAlignment(pt); - const error_align = Type.anyerror.abiAlignment(pt); - const abi_align = ty.abiAlignment(pt); + const payload_align = payload_ty.abiAlignment(zcu); + const error_align = Type.anyerror.abiAlignment(zcu); + const abi_align = ty.abiAlignment(zcu); // error value first when its type is larger than the error union's payload if (error_align.order(payload_align) == .gt) { @@ -317,7 +317,7 @@ pub fn generateSymbol( } }, .enum_tag => |enum_tag| { - const int_tag_ty = ty.intTagType(mod); + const int_tag_ty = ty.intTagType(zcu); switch (try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), code, debug_output, reloc_info)) { .ok => {}, .fail => |em| return .{ .fail = em }, @@ -329,7 +329,7 @@ pub fn generateSymbol( .f64 => |f64_val| writeFloat(f64, f64_val, target, endian, try code.addManyAsArray(8)), .f80 => |f80_val| { writeFloat(f80, f80_val, target, endian, try code.addManyAsArray(10)); - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; try code.appendNTimes(0, abi_size - 10); }, .f128 => |f128_val| writeFloat(f128, f128_val, target, endian, try code.addManyAsArray(16)), @@ -349,11 +349,11 @@ pub fn generateSymbol( } }, .opt => { - const payload_type = ty.optionalChild(mod); - const payload_val = val.optionalValue(mod); - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + const payload_type = ty.optionalChild(zcu); + const payload_val = val.optionalValue(zcu); + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; - if (ty.optionalReprIsPayload(mod)) { + if (ty.optionalReprIsPayload(zcu)) { if (payload_val) |value| { switch (try generateSymbol(bin_file, pt, src_loc, value, code, debug_output, reloc_info)) { .ok => {}, @@ -363,8 +363,8 @@ pub fn generateSymbol( try code.appendNTimes(0, abi_size); } } else { - const padding = abi_size - (math.cast(usize, payload_type.abiSize(pt)) orelse return error.Overflow) - 1; - if (payload_type.hasRuntimeBits(pt)) { + const padding = abi_size - (math.cast(usize, payload_type.abiSize(zcu)) orelse return error.Overflow) - 1; + if (payload_type.hasRuntimeBits(zcu)) { const value = payload_val orelse Value.fromInterned(try pt.intern(.{ .undef = payload_type.toIntern(), })); @@ -398,7 +398,7 @@ pub fn generateSymbol( }, }, .vector_type => |vector_type| { - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; if (vector_type.child == .bool_type) { const bytes = try code.addManyAsSlice(abi_size); @memset(bytes, 0xaa); @@ -458,7 +458,7 @@ pub fn generateSymbol( } const padding = abi_size - - (math.cast(usize, Type.fromInterned(vector_type.child).abiSize(pt) * vector_type.len) orelse + (math.cast(usize, Type.fromInterned(vector_type.child).abiSize(zcu) * vector_type.len) orelse return error.Overflow); if (padding > 0) try code.appendNTimes(0, padding); } @@ -471,7 +471,7 @@ pub fn generateSymbol( 0.., ) |field_ty, comptime_val, index| { if (comptime_val != .none) continue; - if (!Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue; + if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue; const field_val = switch (aggregate.storage) { .bytes => |bytes| try pt.intern(.{ .int = .{ @@ -489,7 +489,7 @@ pub fn generateSymbol( const unpadded_field_end = code.items.len - struct_begin; // Pad struct members if required - const padded_field_end = ty.structFieldOffset(index + 1, pt); + const padded_field_end = ty.structFieldOffset(index + 1, zcu); const padding = math.cast(usize, padded_field_end - unpadded_field_end) orelse return error.Overflow; @@ -502,7 +502,7 @@ pub fn generateSymbol( const struct_type = ip.loadStructType(ty.toIntern()); switch (struct_type.layout) { .@"packed" => { - const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow; + const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow; const current_pos = code.items.len; try code.appendNTimes(0, abi_size); var bits: u16 = 0; @@ -519,8 +519,8 @@ pub fn generateSymbol( // pointer may point to a decl which must be marked used // but can also result in a relocation. Therefore we handle those separately. - if (Type.fromInterned(field_ty).zigTypeTag(mod) == .Pointer) { - const field_size = math.cast(usize, Type.fromInterned(field_ty).abiSize(pt)) orelse + if (Type.fromInterned(field_ty).zigTypeTag(zcu) == .Pointer) { + const field_size = math.cast(usize, Type.fromInterned(field_ty).abiSize(zcu)) orelse return error.Overflow; var tmp_list = try std.ArrayList(u8).initCapacity(code.allocator, field_size); defer tmp_list.deinit(); @@ -531,7 +531,7 @@ pub fn generateSymbol( } else { Value.fromInterned(field_val).writeToPackedMemory(Type.fromInterned(field_ty), pt, code.items[current_pos..], bits) catch unreachable; } - bits += @intCast(Type.fromInterned(field_ty).bitSize(pt)); + bits += @intCast(Type.fromInterned(field_ty).bitSize(zcu)); } }, .auto, .@"extern" => { @@ -542,7 +542,7 @@ pub fn generateSymbol( var it = struct_type.iterateRuntimeOrder(ip); while (it.next()) |field_index| { const field_ty = field_types[field_index]; - if (!Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue; + if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue; const field_val = switch (ip.indexToKey(val.toIntern()).aggregate.storage) { .bytes => |bytes| try pt.intern(.{ .int = .{ @@ -580,7 +580,7 @@ pub fn generateSymbol( else => unreachable, }, .un => |un| { - const layout = ty.unionGetLayout(pt); + const layout = ty.unionGetLayout(zcu); if (layout.payload_size == 0) { return generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, debug_output, reloc_info); @@ -594,11 +594,11 @@ pub fn generateSymbol( } } - const union_obj = mod.typeToUnion(ty).?; + const union_obj = zcu.typeToUnion(ty).?; if (un.tag != .none) { - const field_index = ty.unionTagFieldIndex(Value.fromInterned(un.tag), mod).?; + const field_index = ty.unionTagFieldIndex(Value.fromInterned(un.tag), zcu).?; const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]); - if (!field_ty.hasRuntimeBits(pt)) { + if (!field_ty.hasRuntimeBits(zcu)) { try code.appendNTimes(0xaa, math.cast(usize, layout.payload_size) orelse return error.Overflow); } else { switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, debug_output, reloc_info)) { @@ -606,7 +606,7 @@ pub fn generateSymbol( .fail => |em| return Result{ .fail = em }, } - const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(pt)) orelse return error.Overflow; + const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(zcu)) orelse return error.Overflow; if (padding > 0) { try code.appendNTimes(0, padding); } @@ -661,7 +661,7 @@ fn lowerPtr( reloc_info, offset + errUnionPayloadOffset( Value.fromInterned(eu_ptr).typeOf(zcu).childType(zcu).errorUnionPayload(zcu), - pt, + zcu, ), ), .opt_payload => |opt_ptr| try lowerPtr( @@ -687,7 +687,7 @@ fn lowerPtr( }; }, .Struct, .Union => switch (base_ty.containerLayout(zcu)) { - .auto => base_ty.structFieldOffset(@intCast(field.index), pt), + .auto => base_ty.structFieldOffset(@intCast(field.index), zcu), .@"extern", .@"packed" => unreachable, }, else => unreachable, @@ -713,15 +713,16 @@ fn lowerUavRef( offset: u64, ) CodeGenError!Result { _ = debug_output; - const ip = &pt.zcu.intern_pool; + const zcu = pt.zcu; + const ip = &zcu.intern_pool; const target = lf.comp.root_mod.resolved_target.result; const ptr_width_bytes = @divExact(target.ptrBitWidth(), 8); const uav_val = uav.val; const uav_ty = Type.fromInterned(ip.typeOf(uav_val)); log.debug("lowerUavRef: ty = {}", .{uav_ty.fmt(pt)}); - const is_fn_body = uav_ty.zigTypeTag(pt.zcu) == .Fn; - if (!is_fn_body and !uav_ty.hasRuntimeBits(pt)) { + const is_fn_body = uav_ty.zigTypeTag(zcu) == .Fn; + if (!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) { try code.appendNTimes(0xaa, ptr_width_bytes); return Result.ok; } @@ -768,7 +769,7 @@ fn lowerNavRef( const ptr_width = target.ptrBitWidth(); const nav_ty = Type.fromInterned(ip.getNav(nav_index).typeOf(ip)); const is_fn_body = nav_ty.zigTypeTag(zcu) == .Fn; - if (!is_fn_body and !nav_ty.hasRuntimeBits(pt)) { + if (!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) { try code.appendNTimes(0xaa, @divExact(ptr_width, 8)); return Result.ok; } @@ -860,7 +861,7 @@ fn genNavRef( const ty = val.typeOf(zcu); log.debug("genNavRef: val = {}", .{val.fmtValue(pt)}); - if (!ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) { + if (!ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) { const imm: u64 = switch (@divExact(target.ptrBitWidth(), 8)) { 1 => 0xaa, 2 => 0xaaaa, @@ -994,8 +995,8 @@ pub fn genTypedValue( const info = ty.intInfo(zcu); if (info.bits <= target.ptrBitWidth()) { const unsigned: u64 = switch (info.signedness) { - .signed => @bitCast(val.toSignedInt(pt)), - .unsigned => val.toUnsignedInt(pt), + .signed => @bitCast(val.toSignedInt(zcu)), + .unsigned => val.toUnsignedInt(zcu), }; return .{ .mcv = .{ .immediate = unsigned } }; } @@ -1012,7 +1013,7 @@ pub fn genTypedValue( val.optionalValue(zcu) orelse return .{ .mcv = .{ .immediate = 0 } }, target, ); - } else if (ty.abiSize(pt) == 1) { + } else if (ty.abiSize(zcu) == 1) { return .{ .mcv = .{ .immediate = @intFromBool(!val.isNull(zcu)) } }; } }, @@ -1034,7 +1035,7 @@ pub fn genTypedValue( .ErrorUnion => { const err_type = ty.errorUnionSet(zcu); const payload_type = ty.errorUnionPayload(zcu); - if (!payload_type.hasRuntimeBitsIgnoreComptime(pt)) { + if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) { // We use the error type directly as the type. const err_int_ty = try pt.errorIntType(); switch (ip.indexToKey(val.toIntern()).error_union.val) { @@ -1074,23 +1075,23 @@ pub fn genTypedValue( return lf.lowerUav(pt, val.toIntern(), .none, src_loc); } -pub fn errUnionPayloadOffset(payload_ty: Type, pt: Zcu.PerThread) u64 { - if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0; - const payload_align = payload_ty.abiAlignment(pt); - const error_align = Type.anyerror.abiAlignment(pt); - if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(pt)) { +pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 { + if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0; + const payload_align = payload_ty.abiAlignment(zcu); + const error_align = Type.anyerror.abiAlignment(zcu); + if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) { return 0; } else { - return payload_align.forward(Type.anyerror.abiSize(pt)); + return payload_align.forward(Type.anyerror.abiSize(zcu)); } } -pub fn errUnionErrorOffset(payload_ty: Type, pt: Zcu.PerThread) u64 { - if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0; - const payload_align = payload_ty.abiAlignment(pt); - const error_align = Type.anyerror.abiAlignment(pt); - if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(pt)) { - return error_align.forward(payload_ty.abiSize(pt)); +pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 { + if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0; + const payload_align = payload_ty.abiAlignment(zcu); + const error_align = Type.anyerror.abiAlignment(zcu); + if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) { + return error_align.forward(payload_ty.abiSize(zcu)); } else { return 0; } -- cgit v1.2.3 From f777b298327de95d2a54d814ca562c08fd7c7a87 Mon Sep 17 00:00:00 2001 From: David Rubin Date: Sun, 25 Aug 2024 22:43:57 -0700 Subject: fix up merge conflicts with master --- src/Compilation.zig | 8 ++--- src/Sema.zig | 14 ++++---- src/Type.zig | 63 ++++++++++++++++++++++++++++++-- src/Value.zig | 8 ++--- src/Zcu.zig | 6 ++-- src/Zcu/PerThread.zig | 2 +- src/arch/x86_64/CodeGen.zig | 2 +- src/arch/x86_64/Emit.zig | 2 +- src/codegen.zig | 14 ++++---- src/link/C.zig | 2 +- src/link/Coff.zig | 2 +- src/link/Dwarf.zig | 86 ++++++++++++++++++++++---------------------- src/link/Elf/ZigObject.zig | 6 ++-- src/link/MachO/ZigObject.zig | 4 +-- src/link/Plan9.zig | 2 +- src/link/Wasm/ZigObject.zig | 2 +- 16 files changed, 141 insertions(+), 82 deletions(-) (limited to 'src/codegen.zig') diff --git a/src/Compilation.zig b/src/Compilation.zig index e4c47e4116..61f1a30a6b 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -3091,7 +3091,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle { var all_references: ?std.AutoHashMapUnmanaged(InternPool.AnalUnit, ?Zcu.ResolvedReference) = null; defer if (all_references) |*a| a.deinit(gpa); - if (comp.module) |zcu| { + if (comp.zcu) |zcu| { const ip = &zcu.intern_pool; for (zcu.failed_files.keys(), zcu.failed_files.values()) |file, error_msg| { @@ -3268,7 +3268,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle { } } - if (comp.module) |zcu| { + if (comp.zcu) |zcu| { if (comp.incremental and bundle.root_list.items.len == 0) { const should_have_error = for (zcu.transitive_failed_analysis.keys()) |failed_unit| { if (all_references == null) { @@ -3976,7 +3976,7 @@ fn processOneCodegenJob(tid: usize, comp: *Compilation, codegen_job: CodegenJob) const named_frame = tracy.namedFrame("codegen_type"); defer named_frame.end(); - const pt: Zcu.PerThread = .{ .zcu = comp.module.?, .tid = @enumFromInt(tid) }; + const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) }; try pt.linkerUpdateContainerType(ty); }, } @@ -4258,7 +4258,7 @@ fn workerAstGenFile( const child_prog_node = prog_node.start(file.sub_file_path, 0); defer child_prog_node.end(); - const pt: Zcu.PerThread = .{ .zcu = comp.module.?, .tid = @enumFromInt(tid) }; + const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) }; pt.astGenFile(file, path_digest) catch |err| switch (err) { error.AnalysisFail => return, else => { diff --git a/src/Sema.zig b/src/Sema.zig index 26b683b87a..aafc430c6c 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -3544,7 +3544,7 @@ fn zirAllocExtended( } const target = pt.zcu.getTarget(); try var_ty.resolveLayout(pt); - if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) { + if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) { const var_src = block.src(.{ .node_offset_store_ptr = extra.data.src_node }); return sema.fail(block, var_src, "local variable in naked function", .{}); } @@ -3988,7 +3988,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I if (block.is_comptime) { return sema.analyzeComptimeAlloc(block, var_ty, .none); } - if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) { + if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) { const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node }); return sema.fail(block, mut_src, "local variable in naked function", .{}); } @@ -4016,7 +4016,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai if (block.is_comptime) { return sema.analyzeComptimeAlloc(block, var_ty, .none); } - if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) { + if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) { const var_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node }); return sema.fail(block, var_src, "local variable in naked function", .{}); } @@ -4153,7 +4153,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com // TODO: source location of runtime control flow return sema.fail(block, src, "value with comptime-only type '{}' depends on runtime control flow", .{final_elem_ty.fmt(pt)}); } - if (sema.func_is_naked and try sema.typeHasRuntimeBits(final_elem_ty)) { + if (sema.func_is_naked and try final_elem_ty.hasRuntimeBitsSema(pt)) { const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node }); return sema.fail(block, mut_src, "local variable in naked function", .{}); } @@ -17534,7 +17534,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. .AnyFrame, => {}, } - const val = try ty.lazyAbiSize(pt); + const val = try ty.abiSizeLazy(pt); return Air.internedToRef(val.toIntern()); } @@ -35313,7 +35313,7 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void { if (struct_type.haveLayout(ip)) return; - try sema.resolveTypeFieldsStruct(ty.toIntern(), struct_type); + try sema.resolveStructFieldTypes(ty.toIntern(), struct_type); if (struct_type.layout == .@"packed") { sema.backingIntType(struct_type) catch |err| switch (err) { @@ -38454,7 +38454,7 @@ pub fn resolveDeclaredEnum( wip_ty.setTagTy(ip, int_tag_ty.toIntern()); if (small.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) { - if (fields_len > 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(pt)) { + if (fields_len > 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) { return sema.fail(&block, src, "non-exhaustive enum specifies every value", .{}); } } diff --git a/src/Type.zig b/src/Type.zig index e85e10aacf..5add32a7ac 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -1259,7 +1259,7 @@ pub fn abiSize(ty: Type, zcu: *Zcu) u64 { } /// May capture a reference to `ty`. -pub fn lazyAbiSize(ty: Type, pt: Zcu.PerThread) !Value { +pub fn abiSizeLazy(ty: Type, pt: Zcu.PerThread) !Value { switch (try ty.abiSizeInner(.lazy, pt.zcu, pt.tid)) { .val => |val| return val, .scalar => |x| return pt.intValue(Type.comptime_int, x), @@ -3446,7 +3446,7 @@ pub fn structFieldOffset( const union_type = ip.loadUnionType(ty.toIntern()); if (!union_type.hasTag(ip)) return 0; - const layout = union_type.getUnionLayout(zcu); + const layout = Type.getUnionLayout(union_type, zcu); if (layout.tag_align.compare(.gte, layout.payload_align)) { // {Tag, Payload} return layout.payload_align.forward(layout.tag_size); @@ -4000,6 +4000,65 @@ fn resolveUnionInner( }; } +pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *Zcu) Zcu.UnionLayout { + const ip = &zcu.intern_pool; + assert(loaded_union.haveLayout(ip)); + var most_aligned_field: u32 = undefined; + var most_aligned_field_size: u64 = undefined; + var biggest_field: u32 = undefined; + var payload_size: u64 = 0; + var payload_align: InternPool.Alignment = .@"1"; + for (loaded_union.field_types.get(ip), 0..) |field_ty, field_index| { + if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue; + + const explicit_align = loaded_union.fieldAlign(ip, field_index); + const field_align = if (explicit_align != .none) + explicit_align + else + Type.fromInterned(field_ty).abiAlignment(zcu); + const field_size = Type.fromInterned(field_ty).abiSize(zcu); + if (field_size > payload_size) { + payload_size = field_size; + biggest_field = @intCast(field_index); + } + if (field_align.compare(.gte, payload_align)) { + payload_align = field_align; + most_aligned_field = @intCast(field_index); + most_aligned_field_size = field_size; + } + } + const have_tag = loaded_union.flagsUnordered(ip).runtime_tag.hasTag(); + if (!have_tag or !Type.fromInterned(loaded_union.enum_tag_ty).hasRuntimeBits(zcu)) { + return .{ + .abi_size = payload_align.forward(payload_size), + .abi_align = payload_align, + .most_aligned_field = most_aligned_field, + .most_aligned_field_size = most_aligned_field_size, + .biggest_field = biggest_field, + .payload_size = payload_size, + .payload_align = payload_align, + .tag_align = .none, + .tag_size = 0, + .padding = 0, + }; + } + + const tag_size = Type.fromInterned(loaded_union.enum_tag_ty).abiSize(zcu); + const tag_align = Type.fromInterned(loaded_union.enum_tag_ty).abiAlignment(zcu).max(.@"1"); + return .{ + .abi_size = loaded_union.sizeUnordered(ip), + .abi_align = tag_align.max(payload_align), + .most_aligned_field = most_aligned_field, + .most_aligned_field_size = most_aligned_field_size, + .biggest_field = biggest_field, + .payload_size = payload_size, + .payload_align = payload_align, + .tag_align = tag_align, + .tag_size = tag_size, + .padding = loaded_union.paddingUnordered(ip), + }; +} + /// Returns the type of a pointer to an element. /// Asserts that the type is a pointer, and that the element type is indexable. /// If the element index is comptime-known, it must be passed in `offset`. diff --git a/src/Value.zig b/src/Value.zig index 7861d494a9..516561d581 100644 --- a/src/Value.zig +++ b/src/Value.zig @@ -4196,14 +4196,14 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh const base_ptr_ty = base_ptr.typeOf(zcu); const agg_ty = base_ptr_ty.childType(zcu); const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) { - .Struct => .{ agg_ty.fieldType(field.index, zcu), try agg_ty.fieldAlignmentInner( - field.index, + .Struct => .{ agg_ty.fieldType(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner( + @intCast(field.index), if (have_sema) .sema else .normal, pt.zcu, if (have_sema) pt.tid else {}, ) }, - .Union => .{ agg_ty.unionFieldTypeByIndex(field.index, zcu), try agg_ty.fieldAlignmentInner( - field.index, + .Union => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner( + @intCast(field.index), if (have_sema) .sema else .normal, pt.zcu, if (have_sema) pt.tid else {}, diff --git a/src/Zcu.zig b/src/Zcu.zig index 0eaca2602a..7a03535c2f 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -2840,9 +2840,9 @@ pub fn addTypeReference(zcu: *Zcu, src_unit: AnalUnit, referenced_type: InternPo gop.value_ptr.* = @intCast(ref_idx); } -pub fn errorSetBits(mod: *Zcu) u16 { - if (mod.error_limit == 0) return 0; - return @as(u16, std.math.log2_int(ErrorInt, mod.error_limit)) + 1; +pub fn errorSetBits(zcu: *const Zcu) u16 { + if (zcu.error_limit == 0) return 0; + return @as(u16, std.math.log2_int(ErrorInt, zcu.error_limit)) + 1; } pub fn errNote( diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index b1bdd4e6a1..612921398e 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -1326,7 +1326,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult { try decl_ty.resolveFully(pt); } - if (!resolve_type or !decl_ty.hasRuntimeBits(pt)) { + if (!resolve_type or !decl_ty.hasRuntimeBits(zcu)) { if (zcu.comp.config.use_llvm) break :queue_codegen; if (file.mod.strip) break :queue_codegen; } diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 68e3936d8e..25a951df7b 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -12105,7 +12105,7 @@ fn genLocalDebugInfo( self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op.operand, ), }; - const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, self.pt)); + const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, self.pt.zcu)); try self.genSetMem(.{ .frame = frame_index }, 0, ty, mcv, .{}); try self.asmAirMemory(.dbg_local, inst, .{ .base = .{ .frame = frame_index }, diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig index 0461ce245a..5e0ea0f77c 100644 --- a/src/arch/x86_64/Emit.zig +++ b/src/arch/x86_64/Emit.zig @@ -357,7 +357,7 @@ pub fn emitMir(emit: *Emit) Error!void { } } }; }, }; - const ip = &emit.lower.bin_file.comp.module.?.intern_pool; + const ip = &emit.lower.bin_file.comp.zcu.?.intern_pool; const air_inst = emit.air.instructions.get(@intFromEnum(air_inst_index)); const name: Air.NullTerminatedString = switch (air_inst.tag) { else => unreachable, diff --git a/src/codegen.zig b/src/codegen.zig index 6b69e6a539..7e6a911f5f 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -878,12 +878,12 @@ fn genNavRef( // TODO this feels clunky. Perhaps we should check for it in `genTypedValue`? if (ty.castPtrToFn(zcu)) |fn_ty| { if (zcu.typeToFunc(fn_ty).?.is_generic) { - return .{ .mcv = .{ .immediate = fn_ty.abiAlignment(pt).toByteUnits().? } }; + return .{ .mcv = .{ .immediate = fn_ty.abiAlignment(zcu).toByteUnits().? } }; } } else if (ty.zigTypeTag(zcu) == .Pointer) { const elem_ty = ty.elemType2(zcu); - if (!elem_ty.hasRuntimeBits(pt)) { - return .{ .mcv = .{ .immediate = elem_ty.abiAlignment(pt).toByteUnits().? } }; + if (!elem_ty.hasRuntimeBits(zcu)) { + return .{ .mcv = .{ .immediate = elem_ty.abiAlignment(zcu).toByteUnits().? } }; } } @@ -964,15 +964,15 @@ pub fn genTypedValue( }, else => switch (ip.indexToKey(val.toIntern())) { .int => { - return .{ .mcv = .{ .immediate = val.toUnsignedInt(pt) } }; + return .{ .mcv = .{ .immediate = val.toUnsignedInt(zcu) } }; }, .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) { .nav => |nav| return genNavRef(lf, pt, src_loc, val, nav, target), - .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).hasRuntimeBits(pt)) + .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).hasRuntimeBits(zcu)) return switch (try lf.lowerUav( pt, uav.val, - Type.fromInterned(uav.orig_ty).ptrAlignment(pt), + Type.fromInterned(uav.orig_ty).ptrAlignment(zcu), src_loc, )) { .mcv => |mcv| return .{ .mcv = switch (mcv) { @@ -983,7 +983,7 @@ pub fn genTypedValue( .fail => |em| return .{ .fail = em }, } else - return .{ .mcv = .{ .immediate = Type.fromInterned(uav.orig_ty).ptrAlignment(pt) + return .{ .mcv = .{ .immediate = Type.fromInterned(uav.orig_ty).ptrAlignment(zcu) .forward(@intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() | 1)) / 3)) } }, else => {}, }, diff --git a/src/link/C.zig b/src/link/C.zig index 18e6b5d0eb..7d00ad9028 100644 --- a/src/link/C.zig +++ b/src/link/C.zig @@ -327,7 +327,7 @@ pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) ! .variable => |variable| variable.init, else => nav.status.resolved.val, }; - if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) return; + if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) return; const gop = try self.navs.getOrPut(gpa, nav_index); errdefer _ = self.navs.pop(); diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 323fba7016..fffa412f03 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -1221,7 +1221,7 @@ pub fn updateNav( else => nav_val, }; - if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) { + if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) { const atom_index = try self.getOrCreateAtomForNav(nav_index); Atom.freeRelocations(self, atom_index); const atom = self.getAtom(atom_index); diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig index 26ea6207e8..40c036df9c 100644 --- a/src/link/Dwarf.zig +++ b/src/link/Dwarf.zig @@ -780,7 +780,7 @@ const Entry = struct { else "?", 0), }); - const zcu = dwarf.bin_file.comp.module.?; + const zcu = dwarf.bin_file.comp.zcu.?; const ip = &zcu.intern_pool; for (dwarf.types.keys(), dwarf.types.values()) |ty, other_entry| { const ty_unit: Unit.Index = if (Type.fromInterned(ty).typeDeclInst(zcu)) |inst_index| @@ -1429,7 +1429,7 @@ pub const WipNav = struct { } } else { try wip_nav.abbrevCode(abbrev_code.block); - const bytes = Type.fromInterned(loaded_enum.tag_ty).abiSize(wip_nav.pt); + const bytes = Type.fromInterned(loaded_enum.tag_ty).abiSize(wip_nav.pt.zcu); try uleb128(diw, bytes); big_int.writeTwosComplement(try wip_nav.debug_info.addManyAsSlice(wip_nav.dwarf.gpa, @intCast(bytes)), wip_nav.dwarf.endian); } @@ -1770,7 +1770,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In const ty_reloc_index = try wip_nav.refForward(); try wip_nav.exprloc(.{ .addr = .{ .sym = sym_index } }); try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse - ty.abiAlignment(pt).toByteUnits().?); + ty.abiAlignment(zcu).toByteUnits().?); try diw.writeByte(@intFromBool(false)); wip_nav.finishForward(ty_reloc_index); try wip_nav.abbrevCode(.is_const); @@ -1821,7 +1821,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In const addr: Loc = .{ .addr = .{ .sym = sym_index } }; try wip_nav.exprloc(if (variable.is_threadlocal) .{ .form_tls_address = &addr } else addr); try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse - ty.abiAlignment(pt).toByteUnits().?); + ty.abiAlignment(zcu).toByteUnits().?); try diw.writeByte(@intFromBool(false)); }, .func => |func| { @@ -2158,8 +2158,8 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool try diw.writeByte(accessibility); try wip_nav.strp(nav.name.toSlice(ip)); if (loaded_struct.field_types.len == 0) try diw.writeByte(@intFromBool(false)) else { - try uleb128(diw, nav_val.toType().abiSize(pt)); - try uleb128(diw, nav_val.toType().abiAlignment(pt).toByteUnits().?); + try uleb128(diw, nav_val.toType().abiSize(zcu)); + try uleb128(diw, nav_val.toType().abiAlignment(zcu).toByteUnits().?); for (0..loaded_struct.field_types.len) |field_index| { const is_comptime = loaded_struct.fieldIsComptime(ip, field_index); try wip_nav.abbrevCode(if (is_comptime) .struct_field_comptime else .struct_field); @@ -2173,7 +2173,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool if (!is_comptime) { try uleb128(diw, loaded_struct.offsets.get(ip)[field_index]); try uleb128(diw, loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse - field_type.abiAlignment(pt).toByteUnits().?); + field_type.abiAlignment(zcu).toByteUnits().?); } } try uleb128(diw, @intFromEnum(AbbrevCode.null)); @@ -2195,7 +2195,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool const field_type = Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]); try wip_nav.refType(field_type); try uleb128(diw, field_bit_offset); - field_bit_offset += @intCast(field_type.bitSize(pt)); + field_bit_offset += @intCast(field_type.bitSize(zcu)); } try uleb128(diw, @intFromEnum(AbbrevCode.null)); }, @@ -2360,7 +2360,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool try uleb128(diw, loc.column + 1); try diw.writeByte(accessibility); try wip_nav.strp(nav.name.toSlice(ip)); - const union_layout = pt.getUnionLayout(loaded_union); + const union_layout = Type.getUnionLayout(loaded_union, zcu); try uleb128(diw, union_layout.abi_size); try uleb128(diw, union_layout.abi_align.toByteUnits().?); const loaded_tag = loaded_union.loadTagType(ip); @@ -2391,7 +2391,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool try wip_nav.refType(field_type); try uleb128(diw, union_layout.payloadOffset()); try uleb128(diw, loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse - if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(pt).toByteUnits().?); + if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?); } try uleb128(diw, @intFromEnum(AbbrevCode.null)); } @@ -2406,7 +2406,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool const field_type = Type.fromInterned(loaded_union.field_types.get(ip)[field_index]); try wip_nav.refType(field_type); try uleb128(diw, loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse - field_type.abiAlignment(pt).toByteUnits().?); + field_type.abiAlignment(zcu).toByteUnits().?); } try uleb128(diw, @intFromEnum(AbbrevCode.null)); break :done; @@ -2560,8 +2560,8 @@ fn updateType( inline .signed, .unsigned => |signedness| @field(DW.ATE, @tagName(signedness)), }); try uleb128(diw, int_type.bits); - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); }, .ptr_type => |ptr_type| switch (ptr_type.flags.size) { .One, .Many, .C => { @@ -2569,7 +2569,7 @@ fn updateType( try wip_nav.abbrevCode(.ptr_type); try wip_nav.strp(name); try uleb128(diw, ptr_type.flags.alignment.toByteUnits() orelse - ptr_child_type.abiAlignment(pt).toByteUnits().?); + ptr_child_type.abiAlignment(zcu).toByteUnits().?); try diw.writeByte(@intFromEnum(ptr_type.flags.address_space)); if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try wip_nav.infoSectionOffset( .debug_info, @@ -2594,8 +2594,8 @@ fn updateType( .Slice => { try wip_nav.abbrevCode(.struct_type); try wip_nav.strp(name); - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); try wip_nav.abbrevCode(.generated_field); try wip_nav.strp("ptr"); const ptr_field_type = ty.slicePtrFieldType(zcu); @@ -2605,7 +2605,7 @@ fn updateType( try wip_nav.strp("len"); const len_field_type = Type.usize; try wip_nav.refType(len_field_type); - try uleb128(diw, len_field_type.abiAlignment(pt).forward(ptr_field_type.abiSize(pt))); + try uleb128(diw, len_field_type.abiAlignment(zcu).forward(ptr_field_type.abiSize(zcu))); try uleb128(diw, @intFromEnum(AbbrevCode.null)); }, }, @@ -2623,8 +2623,8 @@ fn updateType( const opt_child_type = Type.fromInterned(opt_child_type_index); try wip_nav.abbrevCode(.union_type); try wip_nav.strp(name); - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); if (opt_child_type.isNoReturn(zcu)) { try wip_nav.abbrevCode(.generated_field); try wip_nav.strp("null"); @@ -2652,8 +2652,8 @@ fn updateType( switch (repr) { .unpacked => { try wip_nav.refType(Type.bool); - try uleb128(diw, if (opt_child_type.hasRuntimeBits(pt)) - opt_child_type.abiSize(pt) + try uleb128(diw, if (opt_child_type.hasRuntimeBits(zcu)) + opt_child_type.abiSize(zcu) else 0); }, @@ -2700,8 +2700,8 @@ fn updateType( const error_union_error_set_offset, const error_union_payload_offset = switch (error_union_type.payload_type) { .generic_poison_type => .{ 0, 0 }, else => .{ - codegen.errUnionErrorOffset(error_union_payload_type, pt), - codegen.errUnionPayloadOffset(error_union_payload_type, pt), + codegen.errUnionErrorOffset(error_union_payload_type, zcu), + codegen.errUnionPayloadOffset(error_union_payload_type, zcu), }, }; @@ -2710,8 +2710,8 @@ fn updateType( if (error_union_type.error_set_type != .generic_poison_type and error_union_type.payload_type != .generic_poison_type) { - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); } else { try uleb128(diw, 0); try uleb128(diw, 1); @@ -2788,9 +2788,9 @@ fn updateType( DW.ATE.unsigned else unreachable); - try uleb128(diw, ty.bitSize(pt)); - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.bitSize(zcu)); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); }, .anyopaque, .void, @@ -2820,8 +2820,8 @@ fn updateType( } else { try wip_nav.abbrevCode(.struct_type); try wip_nav.strp(name); - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); var field_byte_offset: u64 = 0; for (0..anon_struct_type.types.len) |field_index| { const comptime_value = anon_struct_type.values.get(ip)[field_index]; @@ -2834,11 +2834,11 @@ fn updateType( const field_type = Type.fromInterned(anon_struct_type.types.get(ip)[field_index]); try wip_nav.refType(field_type); if (comptime_value == .none) { - const field_align = field_type.abiAlignment(pt); + const field_align = field_type.abiAlignment(zcu); field_byte_offset = field_align.forward(field_byte_offset); try uleb128(diw, field_byte_offset); - try uleb128(diw, field_type.abiAlignment(pt).toByteUnits().?); - field_byte_offset += field_type.abiSize(pt); + try uleb128(diw, field_type.abiAlignment(zcu).toByteUnits().?); + field_byte_offset += field_type.abiSize(zcu); } } try uleb128(diw, @intFromEnum(AbbrevCode.null)); @@ -2976,8 +2976,8 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP try uleb128(diw, file_gop.index); try wip_nav.strp(loaded_struct.name.toSlice(ip)); if (loaded_struct.field_types.len > 0) { - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); for (0..loaded_struct.field_types.len) |field_index| { const is_comptime = loaded_struct.fieldIsComptime(ip, field_index); try wip_nav.abbrevCode(if (is_comptime) .struct_field_comptime else .struct_field); @@ -2991,7 +2991,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP if (!is_comptime) { try uleb128(diw, loaded_struct.offsets.get(ip)[field_index]); try uleb128(diw, loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse - field_type.abiAlignment(pt).toByteUnits().?); + field_type.abiAlignment(zcu).toByteUnits().?); } } try uleb128(diw, @intFromEnum(AbbrevCode.null)); @@ -3042,8 +3042,8 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP try wip_nav.abbrevCode(if (loaded_struct.field_types.len == 0) .namespace_struct_type else .struct_type); try wip_nav.strp(name); if (loaded_struct.field_types.len == 0) try diw.writeByte(@intFromBool(false)) else { - try uleb128(diw, ty.abiSize(pt)); - try uleb128(diw, ty.abiAlignment(pt).toByteUnits().?); + try uleb128(diw, ty.abiSize(zcu)); + try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?); for (0..loaded_struct.field_types.len) |field_index| { const is_comptime = loaded_struct.fieldIsComptime(ip, field_index); try wip_nav.abbrevCode(if (is_comptime) .struct_field_comptime else .struct_field); @@ -3057,7 +3057,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP if (!is_comptime) { try uleb128(diw, loaded_struct.offsets.get(ip)[field_index]); try uleb128(diw, loaded_struct.fieldAlign(ip, field_index).toByteUnits() orelse - field_type.abiAlignment(pt).toByteUnits().?); + field_type.abiAlignment(zcu).toByteUnits().?); } } try uleb128(diw, @intFromEnum(AbbrevCode.null)); @@ -3074,7 +3074,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP const field_type = Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]); try wip_nav.refType(field_type); try uleb128(diw, field_bit_offset); - field_bit_offset += @intCast(field_type.bitSize(pt)); + field_bit_offset += @intCast(field_type.bitSize(zcu)); } if (loaded_struct.field_types.len > 0) try uleb128(diw, @intFromEnum(AbbrevCode.null)); }, @@ -3099,7 +3099,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP const loaded_union = ip.loadUnionType(type_index); try wip_nav.abbrevCode(if (loaded_union.field_types.len > 0) .union_type else .empty_union_type); try wip_nav.strp(name); - const union_layout = pt.getUnionLayout(loaded_union); + const union_layout = Type.getUnionLayout(loaded_union, zcu); try uleb128(diw, union_layout.abi_size); try uleb128(diw, union_layout.abi_align.toByteUnits().?); const loaded_tag = loaded_union.loadTagType(ip); @@ -3130,7 +3130,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP try wip_nav.refType(field_type); try uleb128(diw, union_layout.payloadOffset()); try uleb128(diw, loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse - if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(pt).toByteUnits().?); + if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?); } try uleb128(diw, @intFromEnum(AbbrevCode.null)); } @@ -3145,7 +3145,7 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP const field_type = Type.fromInterned(loaded_union.field_types.get(ip)[field_index]); try wip_nav.refType(field_type); try uleb128(diw, loaded_union.fieldAlign(ip, field_index).toByteUnits() orelse - field_type.abiAlignment(pt).toByteUnits().?); + field_type.abiAlignment(zcu).toByteUnits().?); } if (loaded_union.field_types.len > 0) try uleb128(diw, @intFromEnum(AbbrevCode.null)); }, diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig index 3eff58af73..06cde2bc96 100644 --- a/src/link/Elf/ZigObject.zig +++ b/src/link/Elf/ZigObject.zig @@ -157,7 +157,7 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi } if (build_options.enable_logging) { - const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.module.?, .tid = tid }; + const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid }; for (self.navs.keys(), self.navs.values()) |nav_index, meta| { checkNavAllocated(pt, nav_index, meta); } @@ -167,7 +167,7 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi } if (self.dwarf) |*dwarf| { - const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.module.?, .tid = tid }; + const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid }; try dwarf.flushModule(pt); const gpa = elf_file.base.comp.gpa; @@ -1306,7 +1306,7 @@ pub fn updateNav( else => nav.status.resolved.val, }; - if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) { + if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) { const sym_index = try self.getOrCreateMetadataForNav(elf_file, nav_index); self.symbol(sym_index).atom(elf_file).?.freeRelocs(self); diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig index 340c5cbff8..fb1630fcd5 100644 --- a/src/link/MachO/ZigObject.zig +++ b/src/link/MachO/ZigObject.zig @@ -595,7 +595,7 @@ pub fn flushModule(self: *ZigObject, macho_file: *MachO, tid: Zcu.PerThread.Id) } if (self.dwarf) |*dwarf| { - const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.module.?, .tid = tid }; + const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.zcu.?, .tid = tid }; try dwarf.flushModule(pt); self.debug_abbrev_dirty = false; @@ -887,7 +887,7 @@ pub fn updateNav( else => nav.status.resolved.val, }; - if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) { + if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) { const sym_index = try self.getOrCreateMetadataForNav(macho_file, nav_index); self.symbols.items[sym_index].getAtom(macho_file).?.freeRelocs(macho_file); diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig index 335c418124..080b6853e7 100644 --- a/src/link/Plan9.zig +++ b/src/link/Plan9.zig @@ -457,7 +457,7 @@ pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde else => nav_val, }; - if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) { + if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) { const atom_idx = try self.seeNav(pt, nav_index); var code_buffer = std.ArrayList(u8).init(gpa); diff --git a/src/link/Wasm/ZigObject.zig b/src/link/Wasm/ZigObject.zig index f768e7f900..eff9bbf638 100644 --- a/src/link/Wasm/ZigObject.zig +++ b/src/link/Wasm/ZigObject.zig @@ -259,7 +259,7 @@ pub fn updateNav( else => .{ false, .none, nav_val }, }; - if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) { + if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) { const gpa = wasm_file.base.comp.gpa; const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index); const atom = wasm_file.getAtomPtr(atom_index); -- cgit v1.2.3