From bf68590236d6d7ceb0283cb706d76717755c896a Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Sun, 6 Sep 2026 16:19:36 -0400 Subject: [PATCH] Dwarf2: implement comptime navs --- src/Zcu/PerThread.zig | 22 +++- src/link/Dwarf2.zig | 260 ++++++++++++++++++++++++++++++++---------- src/link/Elf2.zig | 68 +++++------ test/src/Debugger.zig | 2 +- 4 files changed, 257 insertions(+), 95 deletions(-) diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index f1609662a6719719e1fef3dfe19d2df46e77c21a..bfcf8dca46a25500bda95171d37dfa4a27710fed 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -2657,7 +2657,13 @@ fn computeAliveFiles(pt: Zcu.PerThread) Allocator.Error!bool { // We've not necessarily generated builtin modules yet, so `doImport` could fail. Instead, // create the module here. Then, since we know that `builtin.zig` doesn't have an error and // has no imports other than 'std', we can just continue onto the next import. - try pt.updateBuiltinModule(file.mod.?.getBuiltinOptions(comp.config)); + const res = try pt.updateBuiltinModule(file.mod.?.getBuiltinOptions(comp.config)); + const gop = zcu.alive_files.getOrPutAssumeCapacity(res.file); + if (!gop.found_existing) gop.value_ptr.* = .{ .import = .{ + .importer = file_idx, + .tok = item.data.token, + .module = res.module_root, + } }; continue; } @@ -2756,14 +2762,20 @@ fn computeAliveFiles(pt: Zcu.PerThread) Allocator.Error!bool { /// up-to-date, setting a misc failure if updating it fails. /// Asserts that the imported `builtin.zig` has no ZIR errors, and that it has only one /// import, which is 'std'. -pub fn updateBuiltinModule(pt: Zcu.PerThread, opts: Builtin) Allocator.Error!void { +fn updateBuiltinModule(pt: Zcu.PerThread, opts: Builtin) Allocator.Error!struct { + file: Zcu.File.Index, + module_root: *Module, +} { const zcu = pt.zcu; const comp = zcu.comp; const gpa = comp.gpa; const io = comp.io; const gop = try zcu.builtin_modules.getOrPut(gpa, opts.hash()); - if (gop.found_existing) return; // the `File` is up-to-date + if (gop.found_existing) return .{ // the `File` is up-to-date + .file = zcu.module_roots.get(gop.value_ptr.*).?.unwrap().?, + .module_root = gop.value_ptr.*, + }; errdefer _ = zcu.builtin_modules.pop(); const mod: *Module = try .createBuiltin(comp.arena, opts, comp.dirs); @@ -2829,6 +2841,10 @@ pub fn updateBuiltinModule(pt: Zcu.PerThread, opts: Builtin) Allocator.Error!voi "unable to write '{f}': {s}", .{ file.path.fmt(comp), @errorName(err) }, ); + return .{ + .file = file_index, + .module_root = mod, + }; } pub fn embedFile( diff --git a/src/link/Dwarf2.zig b/src/link/Dwarf2.zig index b088c95f0714eef4ff825e9cba486f52cfd42f16..ec2e1a446c4c0b867007dca1d4c2cfec688bf958 100644 --- a/src/link/Dwarf2.zig +++ b/src/link/Dwarf2.zig @@ -81,6 +81,7 @@ pub const Unit = struct { ui: Unit.Index, zfi: Zcu.File.Index, ) std.mem.Allocator.Error!struct { DirIndex, FileIndex } { + assert(unit.alive); try unit.dirs.ensureUnusedCapacity(gpa, 1); try unit.files.ensureUnusedCapacity(gpa, 1); const dir_gop = unit.dirs.getOrPutAssumeCapacity(ui); @@ -737,8 +738,8 @@ pub const WipNav = struct { try dl_w.writeByte(DW.LNE.set_address); try dwarf.addrSym(dl_nw, debug.wip_nav.func_si, 0); - const unit = dwarf.getUnit(zf.mod.?); - _, const fi = try unit.get(dwarf).getFile(zcu.gpa, unit, inst_info.file); + const ui = dwarf.getUnit(zf.mod.?); + _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, inst_info.file); try dl_w.writeByte(DW.LNS.set_file); try dl_w.writeUleb128(@backingInt(fi)); @@ -1515,7 +1516,6 @@ pub fn getDecl( pt: Zcu.PerThread, instance_val: InternPool.Index, ) link.Error!link.MappedFile.Node.Index { - assert(dwarf.pending_decl.instance_val == .none); const comp = dwarf.lf.comp; const gpa = comp.gpa; const zcu = pt.zcu; @@ -1949,11 +1949,11 @@ pub fn genDebugRnglists( pub fn updateComptimeNav( dwarf: *Dwarf, pt: Zcu.PerThread, - nav_index: InternPool.Nav.Index, + ni: InternPool.Nav.Index, ) link.Error!void { const zcu = pt.zcu; const ip = &zcu.intern_pool; - const nav = ip.getNav(nav_index); + const nav = ip.getNav(ni); log.debug("updateComptimeNav({f})", .{nav.fqn.fmt(ip)}); const inst_info = nav.srcInst(ip).resolveFull(ip).?; const nav_val: Value = .fromInterned(nav.resolved.?.value); @@ -1964,49 +1964,184 @@ pub fn updateComptimeNav( .@"comptime", .@"const", .@"var" => {}, } done: switch (ip.indexToKey(nav_val.toIntern())) { + .int_type, + .ptr_type, + .array_type, + .vector_type, + .opt_type, + .error_union_type, + .anyframe_type, + .simple_type, + .tuple_type, + .func_type, + .error_set_type, + .inferred_error_set_type, + .spirv_type, + => try dwarf.genDeclType(pt, ni, &decl), .struct_type => { const loaded_struct = ip.loadStructType(nav_val.toIntern()); - if (nav_index.toOptional() == loaded_struct.name_nav) { - _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()); - break :done; - } - return; + if (ni.toOptional() == loaded_struct.name_nav) + _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()) + else + try dwarf.genDeclType(pt, ni, &decl); }, .enum_type => { const loaded_enum = ip.loadEnumType(nav_val.toIntern()); - if (nav_index.toOptional() == loaded_enum.name_nav) { - _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()); - break :done; - } - return; + if (ni.toOptional() == loaded_enum.name_nav) + _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()) + else + try dwarf.genDeclType(pt, ni, &decl); }, .union_type => { const loaded_union = ip.loadUnionType(nav_val.toIntern()); - if (nav_index.toOptional() == loaded_union.name_nav) { - _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()); - break :done; - } - return; + if (ni.toOptional() == loaded_union.name_nav) + _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()) + else + try dwarf.genDeclType(pt, ni, &decl); }, .opaque_type => { const loaded_opaque = ip.loadOpaqueType(nav_val.toIntern()); - if (nav_index.toOptional() == loaded_opaque.name_nav) { - _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()); - break :done; - } - return; + if (ni.toOptional() == loaded_opaque.name_nav) + _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()) + else + try dwarf.genDeclType(pt, ni, &decl); }, - .func => |func| if (func.owner_nav == nav_index and func.generic_owner == .none) { + .undef, + .simple_value, + .int, + .err, + .error_union, + .enum_literal, + .enum_tag, + .float, + .ptr, + .slice, + .opt, + .aggregate, + .un, + .bitpack, + => try dwarf.genDeclValue(pt, ni, &decl), + .@"extern" => unreachable, + .func => |func| if (func.owner_nav == ni and func.generic_owner == .none) { _ = try dwarf.const_pool.get(pt, dwarf.constPoolUser(), nav_val.toIntern()); break :done; } else return, - - else => return, - // memoization, not values .memoized_call => unreachable, } - try dwarf.const_pool.flushPending(pt, dwarf.constPoolUser()); +} + +fn genDeclType( + dwarf: *Dwarf, + pt: Zcu.PerThread, + ni: InternPool.Nav.Index, + decl: *const std.zig.Zir.Inst.Declaration.Unwrapped, +) link.Error!void { + const gi = try dwarf.getGlobal(ni); + const debug_info_ni = gi.get(dwarf).debug_info_ni.unwrap().?; + var di_nw: link.MappedFile.Node.Writer = undefined; + if (dwarf.lf.cast(.elf2)) |elf| { + debug_info_ni.writer(pt.zcu.gpa, &elf.mf, &di_nw); + elf.resetNodeRelocs(debug_info_ni); + } else unreachable; + defer di_nw.deinit(); + dwarf.genDeclTypeInner(pt, &di_nw, ni, decl) catch |err| switch (err) { + error.WriteFailed => return dwarf.reportWriteError(&di_nw), + else => |e| return e, + }; +} +fn genDeclTypeInner( + dwarf: *Dwarf, + pt: Zcu.PerThread, + di_nw: *link.MappedFile.Node.Writer, + ni: InternPool.Nav.Index, + decl: *const std.zig.Zir.Inst.Declaration.Unwrapped, +) link.EmitError!void { + const ip = &pt.zcu.intern_pool; + const nav = ip.getNav(ni); + const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(nav.analysis.?.namespace).owner_type); + const di_w = &di_nw.interface; + try dwarf.abbrevCode(di_nw, .decl_type); + try dwarf.secOffset(di_nw, parent_ni, 0); + try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); + try di_w.writeUleb128(decl.src_column + 1); + try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); + try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); + try dwarf.refConst(pt, di_nw, .fromInterned(nav.resolved.?.value)); + try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); +} + +fn genDeclValue( + dwarf: *Dwarf, + pt: Zcu.PerThread, + ni: InternPool.Nav.Index, + decl: *const std.zig.Zir.Inst.Declaration.Unwrapped, +) link.Error!void { + const gi = try dwarf.getGlobal(ni); + const debug_info_ni = gi.get(dwarf).debug_info_ni.unwrap().?; + var di_nw: link.MappedFile.Node.Writer = undefined; + if (dwarf.lf.cast(.elf2)) |elf| { + debug_info_ni.writer(pt.zcu.gpa, &elf.mf, &di_nw); + elf.resetNodeRelocs(debug_info_ni); + } else unreachable; + defer di_nw.deinit(); + dwarf.genDeclValueInner(pt, &di_nw, ni, decl) catch |err| switch (err) { + error.WriteFailed => return dwarf.reportWriteError(&di_nw), + else => |e| return e, + }; +} +fn genDeclValueInner( + dwarf: *Dwarf, + pt: Zcu.PerThread, + di_nw: *link.MappedFile.Node.Writer, + ni: InternPool.Nav.Index, + decl: *const std.zig.Zir.Inst.Declaration.Unwrapped, +) link.EmitError!void { + const zcu = pt.zcu; + const ip = &zcu.intern_pool; + const nav = ip.getNav(ni); + const nav_const, const nav_ty: Type, const nav_align, const nav_val: Value = resolved: { + const resolved = nav.resolved.?; + break :resolved .{ + resolved.@"const", + .fromInterned(resolved.type), + resolved.@"align", + .fromInterned(resolved.value), + }; + }; + const nav_class = nav_ty.classify(zcu); + const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(nav.analysis.?.namespace).owner_type); + const di_w = &di_nw.interface; + try dwarf.abbrevCode(di_nw, if (nav_const) switch (nav_class) { + .no_possible_value, .one_possible_value => .decl_const, + .runtime => .decl_const_fully_runtime, + .partially_comptime => .decl_const_partially_comptime, + .fully_comptime => .decl_const_fully_comptime, + } else .decl_var); + try dwarf.secOffset(di_nw, parent_ni, 0); + try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); + try di_w.writeUleb128(decl.src_column + 1); + try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); + try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); + try dwarf.strp(&dwarf.debug_str, di_nw, switch (decl.linkage) { + .normal => nav.fqn, + .@"extern", .@"export" => nav.name, + }.toSlice(ip)); + const type_offset = di_w.end; + if (nav_const) try dwarf.secOffsetPlaceholder(di_w) else { + try dwarf.refType(pt, di_nw, nav_ty); + try dwarf.blockConst(pt, di_nw, nav_val); + } + try di_w.writeUleb128(nav_align.toByteUnits() orelse nav_ty.abiAlignment(zcu).toByteUnits().?); + try di_w.writeByte(@intFromBool(decl.linkage != .normal)); + if (nav_const) { + if (nav_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, nav_val); + if (nav_class.comptimeOnly()) try dwarf.refConst(pt, di_nw, nav_val); + try dwarf.secOffsetFinish(di_nw, type_offset, di_nw.ni, di_w.end); + try dwarf.abbrevCode(di_nw, .is_const); + try dwarf.refType(pt, di_nw, nav_ty); + } + try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); } pub fn addConst( @@ -2044,9 +2179,11 @@ pub fn addConst( const name_gi = try dwarf.getGlobal(name_nav); break :debug_info_ni name_gi.get(dwarf).debug_info_ni.unwrap().?; } - break :debug_info_ni try addConstNode(dwarf.lf, dwarf.getUnit(zcu.fileByIndex( + const mod = zcu.fileByIndex( Type.fromInterned(val).typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(ip), - ).mod.?), cpi); + ).mod.?; + assert(!mod.strip); + break :debug_info_ni try addConstNode(dwarf.lf, dwarf.getUnit(mod), cpi); }, }.toOptional(), }); @@ -2456,9 +2593,8 @@ fn updateConstInner( } else if (loaded_struct.name_nav.unwrap()) |name_ni| { const name_nav = ip.getNav(name_ni); const decl = zf.zir.?.getDeclaration(name_nav.srcInst(ip).resolve(ip).?); - const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( - name_nav.analysis.?.namespace, - ).owner_type); + const parent_ni = + try dwarf.getDecl(pt, ip.namespacePtr(name_nav.analysis.?.namespace).owner_type); try dwarf.abbrevCode(di_nw, if (loaded_struct.field_types.len > 0) switch (loaded_struct.layout) { .auto, .@"extern" => .decl_struct, @@ -2589,9 +2725,8 @@ fn updateConstInner( } else if (loaded_union.name_nav.unwrap()) |name_ni| { const name_nav = ip.getNav(name_ni); const decl = zf.zir.?.getDeclaration(name_nav.srcInst(ip).resolve(ip).?); - const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( - name_nav.analysis.?.namespace, - ).owner_type); + const parent_ni = + try dwarf.getDecl(pt, ip.namespacePtr(name_nav.analysis.?.namespace).owner_type); try dwarf.abbrevCode(di_nw, if (loaded_union.field_types.len > 0) switch (loaded_union.layout) { .auto, .@"extern" => .decl_union, @@ -3137,9 +3272,8 @@ fn updateConstIncompleteInner( } else if (maybe_name_nav.unwrap()) |name_ni| { const name_nav = ip.getNav(name_ni); const decl = zf.zir.?.getDeclaration(name_nav.srcInst(ip).resolve(ip).?); - const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( - name_nav.analysis.?.namespace, - ).owner_type); + const parent_ni = + try dwarf.getDecl(pt, ip.namespacePtr(name_nav.analysis.?.namespace).owner_type); try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) { .@"struct" => .decl_incomplete_struct, .@"union" => .decl_incomplete_union, @@ -3399,9 +3533,8 @@ fn genDeclInner( if (maybe_name_nav.unwrap()) |name_ni| { const name_nav = ip.getNav(name_ni); const decl = zir.getDeclaration(name_nav.srcInst(ip).resolve(ip).?); - const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( - name_nav.analysis.?.namespace, - ).owner_type); + const parent_ni = + try dwarf.getDecl(pt, ip.namespacePtr(name_nav.analysis.?.namespace).owner_type); try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) { .@"struct" => .decl_specification_struct, .@"union" => .decl_specification_union, @@ -3537,9 +3670,6 @@ pub fn secOffsetSize(dwarf: *Dwarf) usize { .@"64" => 8, }; } -fn secOffsetPlaceholder(dwarf: *Dwarf, w: *std.Io.Writer) std.Io.Writer.Error!void { - @memset(try w.writableSlice(dwarf.secOffsetSize()), undefined); -} fn secOffset( dwarf: *Dwarf, nw: *link.MappedFile.Node.Writer, @@ -3548,6 +3678,18 @@ fn secOffset( ) link.EmitError!void { const offset = nw.interface.end; try dwarf.secOffsetPlaceholder(&nw.interface); + try dwarf.secOffsetFinish(nw, offset, target_ni, addend); +} +fn secOffsetPlaceholder(dwarf: *Dwarf, w: *std.Io.Writer) std.Io.Writer.Error!void { + @memset(try w.writableSlice(dwarf.secOffsetSize()), undefined); +} +fn secOffsetFinish( + dwarf: *Dwarf, + nw: *link.MappedFile.Node.Writer, + offset: usize, + target_ni: link.MappedFile.Node.Index, + addend: usize, +) link.Error!void { if (dwarf.lf.cast(.elf2)) |elf| try elf.addNodeReloc( nw.ni, offset, @@ -3745,7 +3887,7 @@ pub const AbbrevCode = enum { pad_n, // decl, specification, and instance codes are assumed to all have the same uleb128 size decl_lost, - decl_alias, + decl_type, decl_empty_incomplete_enum, decl_incomplete_enum, decl_empty_enum, @@ -3780,9 +3922,9 @@ pub const AbbrevCode = enum { type_decl_packed_union, decl_var, decl_const, - decl_const_runtime_bits, - decl_const_comptime_state, - decl_const_runtime_bits_comptime_state, + decl_const_fully_runtime, + decl_const_partially_comptime, + decl_const_fully_comptime, decl_empty_func, decl_func, decl_empty_func_generic, @@ -3802,7 +3944,7 @@ pub const AbbrevCode = enum { type_decl_specification_empty_union, type_decl_specification_union, decl_specification_func, - decl_instance_alias, + decl_instance_type, decl_instance_empty_incomplete_enum, decl_instance_incomplete_enum, decl_instance_empty_enum, @@ -3921,7 +4063,7 @@ pub const AbbrevCode = enum { comptime { assert(uleb128Size(@backingInt(AbbrevCode.pad_1)) == 1); assert(uleb128Size(@backingInt(AbbrevCode.pad_n)) == 1); - assert(uleb128Size(@backingInt(AbbrevCode.decl_alias)) == decl_size); + assert(uleb128Size(@backingInt(AbbrevCode.decl_type)) == decl_size); } const Attr = struct { @@ -3969,7 +4111,7 @@ pub const AbbrevCode = enum { .decl_lost = .{ .tag = .ZIG_lost_declaration, }, - .decl_alias = .{ + .decl_type = .{ .tag = .imported_declaration, .attrs = decl_attrs ++ .{ .{ .import, .ref_addr }, @@ -4186,7 +4328,7 @@ pub const AbbrevCode = enum { .{ .external, .flag }, }, }, - .decl_const_runtime_bits = .{ + .decl_const_fully_runtime = .{ .tag = .constant, .attrs = decl_attrs ++ .{ .{ .linkage_name, .strp }, @@ -4196,24 +4338,24 @@ pub const AbbrevCode = enum { .{ .const_value, .block }, }, }, - .decl_const_comptime_state = .{ + .decl_const_partially_comptime = .{ .tag = .constant, .attrs = decl_attrs ++ .{ .{ .linkage_name, .strp }, .{ .type, .ref_addr }, .{ .alignment, .udata }, .{ .external, .flag }, + .{ .const_value, .block }, .{ .ZIG_comptime_value, .ref_addr }, }, }, - .decl_const_runtime_bits_comptime_state = .{ + .decl_const_fully_comptime = .{ .tag = .constant, .attrs = decl_attrs ++ .{ .{ .linkage_name, .strp }, .{ .type, .ref_addr }, .{ .alignment, .udata }, .{ .external, .flag }, - .{ .const_value, .block }, .{ .ZIG_comptime_value, .ref_addr }, }, }, @@ -4334,7 +4476,7 @@ pub const AbbrevCode = enum { .tag = .subprogram, .attrs = decl_specification_attrs, }, - .decl_instance_alias = .{ + .decl_instance_type = .{ .tag = .imported_declaration, .attrs = decl_instance_attrs ++ .{ .{ .import, .ref_addr }, diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig index c813e7eae06fb7a110bf79d1e09bb385d4f930ff..d2d364ff9de4e8ab84172c27f47925e0e5b60fec 100644 --- a/src/link/Elf2.zig +++ b/src/link/Elf2.zig @@ -7197,7 +7197,7 @@ fn prelinkInner(elf: *Elf) Error!void { }; elf.input_pending_index += 1; - try elf.nodes.ensureUnusedCapacity(gpa, 5 + 4); + try elf.nodes.ensureUnusedCapacity(gpa, 4 + 5); switch (elf.shndx.debug_abbrev) { .UNDEF => {}, @@ -7301,7 +7301,7 @@ fn zcuFilesReadyInner(elf: *Elf, zcu: *Zcu) Error!void { }); } if (!try elf.dwarf.updateUnits(zcu)) return; - try elf.nodes.ensureUnusedCapacity(gpa, 5 * units_len); + try elf.nodes.ensureUnusedCapacity(gpa, 6 * units_len); for (0..units_len) |unit_index| { const ui: Dwarf.Unit.Index = @fromBackingInt(@intCast(unit_index)); const unit = ui.get(&elf.dwarf); @@ -8633,37 +8633,37 @@ fn updateNavInner(elf: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) const nav = ip.getNav(nav_index); if (ip.indexToKey(nav.resolved.?.value) == .@"extern") return; - if (!Type.fromInterned(nav.resolved.?.type).hasRuntimeBits(zcu)) { + if (Type.fromInterned(nav.resolved.?.type).hasRuntimeBits(zcu)) { + const nmi = try elf.navMapIndex(zcu, nav_index); + const ni = nmi.symbol(elf).index().ptr(elf).node.unwrap().?; + + // Ensure the NAV is marked as moved so that once we're done, `flushMoved` will eventually be + // called to apply the NAV's new relocations. + try ni.moved(gpa, &elf.mf); + + { + var nw: MappedFile.Node.Writer = undefined; + ni.writer(gpa, &elf.mf, &nw); + defer nw.deinit(); + elf.resetNodeRelocs(ni); + codegen.generateSymbol( + &elf.base, + pt, + .fromInterned(nav.resolved.?.value), + &nw.interface, + .{ .atom_index = Node.toAtom(ni) }, + ) catch |err| switch (err) { + else => |e| return e, + error.WriteFailed => return nw.err.?, + }; + switch (elf.symPtr(nmi.symbol(elf).index())) { + inline else => |sym| elf.targetStore(&sym.size, @intCast(nw.interface.end)), + } + } + } else { if (elf.ehdrMachine() != .X86_64) return; const mod = zcu.fileByIndex(nav.srcInst(ip).resolveFile(ip)).mod.?; - return if (!mod.strip) elf.dwarf.updateComptimeNav(pt, nav_index); - } - - const nmi = try elf.navMapIndex(zcu, nav_index); - const ni = nmi.symbol(elf).index().ptr(elf).node.unwrap().?; - - // Ensure the NAV is marked as moved so that once we're done, `flushMoved` will eventually be - // called to apply the NAV's new relocations. - try ni.moved(gpa, &elf.mf); - - { - var nw: MappedFile.Node.Writer = undefined; - ni.writer(gpa, &elf.mf, &nw); - defer nw.deinit(); - elf.resetNodeRelocs(ni); - codegen.generateSymbol( - &elf.base, - pt, - .fromInterned(nav.resolved.?.value), - &nw.interface, - .{ .atom_index = Node.toAtom(ni) }, - ) catch |err| switch (err) { - else => |e| return e, - error.WriteFailed => return nw.err.?, - }; - switch (elf.symPtr(nmi.symbol(elf).index())) { - inline else => |sym| elf.targetStore(&sym.size, @intCast(nw.interface.end)), - } + if (!mod.strip) try elf.dwarf.updateComptimeNav(pt, nav_index); } // The NAV's node is done---now generate any UAVs or lazy code/data which the NAV needs. @@ -8726,7 +8726,11 @@ pub fn addConst( .code_view => unreachable, } } -fn addConstNode(lf: *link.File, ui: Dwarf.Unit.Index, cpi: link.ConstPool.Index) link.Error!MappedFile.Node.Index { +fn addConstNode( + lf: *link.File, + ui: Dwarf.Unit.Index, + cpi: link.ConstPool.Index, +) link.Error!MappedFile.Node.Index { const elf = lf.cast(.elf2).?; const unit = ui.get(&elf.dwarf); const debug_info_ni = elf.addNodeAssumeCapacity( diff --git a/test/src/Debugger.zig b/test/src/Debugger.zig index 3df5598ec36c8c6f5f18815e79282052eac55dd0..b96cd2d16c606f3ef556ee138929e5958a62db19 100644 --- a/test/src/Debugger.zig +++ b/test/src/Debugger.zig @@ -629,7 +629,7 @@ pub fn addTests(db: *Debugger) void { \\(lldb) breakpoint delete --force 1 \\1 breakpoints deleted; 0 breakpoint locations disabled. }, - .{ .skip_new_linker = true }, + .{ .skip_new_linker = true }, // passes, but prints errors ); db.addLldbTest( "optionals", -- 2.54.0