authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2026-09-02 10:17:31-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2026-09-03 12:59:38-04:00
logbe38eff2c0723d995df56c97bc582c8403c6803d
tree1965bd5a198f21b686bc0b41b177953385780e33
parent549c32e138afc9d6d9883d9a31d103e6ee18f24f

Dwarf2: style

2 files changed, 769 insertions(+), 621 deletions(-)

src/link/Dwarf2.zig+764-618
......@@ -491,22 +491,23 @@ pub const Cfa = union(enum) {
491491 const RegExpr = struct { reg: u32, expr: Loc };
492492
493493 fn write(cfa: Cfa, wip_nav: *WipNav) link.EmitError!void {
494 const dfw = &wip_nav.fde_writer.interface;
494 const df_nw = &wip_nav.fde_writer;
495 const df_w = &df_nw.interface;
495496 switch (cfa) {
496 .nop => try dfw.writeByte(DW.CFA.nop),
497 .nop => try df_w.writeByte(DW.CFA.nop),
497498 .advance_loc => |loc| {
498499 const delta =
499500 @divExact(loc - wip_nav.cfi.loc, wip_nav.dwarf.frame.header.code_alignment_factor);
500501 if (delta == 0) {} else if (std.math.cast(u6, delta)) |small_delta|
501 try dfw.writeByte(@as(u8, DW.CFA.advance_loc) + small_delta)
502 try df_w.writeByte(@as(u8, DW.CFA.advance_loc) + small_delta)
502503 else if (std.math.cast(u8, delta)) |ubyte_delta|
503 try dfw.writeAll(&.{ DW.CFA.advance_loc1, ubyte_delta })
504 try df_w.writeAll(&.{ DW.CFA.advance_loc1, ubyte_delta })
504505 else if (std.math.cast(u16, delta)) |uhalf_delta| {
505 try dfw.writeByte(DW.CFA.advance_loc2);
506 try dfw.writeInt(u16, uhalf_delta, wip_nav.dwarf.endian);
506 try df_w.writeByte(DW.CFA.advance_loc2);
507 try df_w.writeInt(u16, uhalf_delta, wip_nav.dwarf.endian);
507508 } else if (std.math.cast(u32, delta)) |uword_delta| {
508 try dfw.writeByte(DW.CFA.advance_loc4);
509 try dfw.writeInt(u32, uword_delta, wip_nav.dwarf.endian);
509 try df_w.writeByte(DW.CFA.advance_loc4);
510 try df_w.writeInt(u32, uword_delta, wip_nav.dwarf.endian);
510511 }
511512 wip_nav.cfi.loc = loc;
512513 },
......@@ -518,41 +519,41 @@ pub const Cfa = union(enum) {
518519 }, wip_nav.dwarf.frame.header.data_alignment_factor);
519520 if (std.math.cast(u63, factored_off)) |unsigned_off| {
520521 if (std.math.cast(u6, reg_off.reg)) |small_reg| {
521 try dfw.writeByte(@as(u8, DW.CFA.offset) + small_reg);
522 try df_w.writeByte(@as(u8, DW.CFA.offset) + small_reg);
522523 } else {
523 try dfw.writeByte(DW.CFA.offset_extended);
524 try dfw.writeUleb128(reg_off.reg);
524 try df_w.writeByte(DW.CFA.offset_extended);
525 try df_w.writeUleb128(reg_off.reg);
525526 }
526 try dfw.writeUleb128(unsigned_off);
527 try df_w.writeUleb128(unsigned_off);
527528 } else {
528 try dfw.writeByte(DW.CFA.offset_extended_sf);
529 try dfw.writeUleb128(reg_off.reg);
530 try dfw.writeSleb128(factored_off);
529 try df_w.writeByte(DW.CFA.offset_extended_sf);
530 try df_w.writeUleb128(reg_off.reg);
531 try df_w.writeSleb128(factored_off);
531532 }
532533 },
533534 .restore => |reg| if (std.math.cast(u6, reg)) |small_reg|
534 try dfw.writeByte(@as(u8, DW.CFA.restore) + small_reg)
535 try df_w.writeByte(@as(u8, DW.CFA.restore) + small_reg)
535536 else {
536 try dfw.writeByte(DW.CFA.restore_extended);
537 try dfw.writeUleb128(reg);
537 try df_w.writeByte(DW.CFA.restore_extended);
538 try df_w.writeUleb128(reg);
538539 },
539540 .undefined => |reg| {
540 try dfw.writeByte(DW.CFA.undefined);
541 try dfw.writeUleb128(reg);
541 try df_w.writeByte(DW.CFA.undefined);
542 try df_w.writeUleb128(reg);
542543 },
543544 .same_value => |reg| {
544 try dfw.writeByte(DW.CFA.same_value);
545 try dfw.writeUleb128(reg);
545 try df_w.writeByte(DW.CFA.same_value);
546 try df_w.writeUleb128(reg);
546547 },
547548 .register => |regs| if (regs[0] != regs[1]) {
548 try dfw.writeByte(DW.CFA.register);
549 for (regs) |reg| try dfw.writeUleb128(reg);
549 try df_w.writeByte(DW.CFA.register);
550 for (regs) |reg| try df_w.writeUleb128(reg);
550551 } else {
551 try dfw.writeByte(DW.CFA.same_value);
552 try dfw.writeUleb128(regs[0]);
552 try df_w.writeByte(DW.CFA.same_value);
553 try df_w.writeUleb128(regs[0]);
553554 },
554 .remember_state => try dfw.writeByte(DW.CFA.remember_state),
555 .restore_state => try dfw.writeByte(DW.CFA.restore_state),
555 .remember_state => try df_w.writeByte(DW.CFA.remember_state),
556 .restore_state => try df_w.writeByte(DW.CFA.restore_state),
556557 .def_cfa, .def_cfa_register, .def_cfa_offset, .adjust_cfa_offset => {
557558 const reg_off: RegOff = switch (cfa) {
558559 else => unreachable,
......@@ -568,54 +569,54 @@ pub const Cfa = union(enum) {
568569 const unsigned_off = std.math.cast(u63, reg_off.off);
569570 if (reg_off.off == wip_nav.cfi.cfa.off) {
570571 if (changed_reg) {
571 try dfw.writeByte(DW.CFA.def_cfa_register);
572 try dfw.writeUleb128(reg_off.reg);
572 try df_w.writeByte(DW.CFA.def_cfa_register);
573 try df_w.writeUleb128(reg_off.reg);
573574 }
574575 } else if (switch (wip_nav.dwarf.frame.header.data_alignment_factor) {
575576 0 => unreachable,
576577 1 => unsigned_off != null,
577578 else => |data_alignment_factor| @rem(reg_off.off, data_alignment_factor) != 0,
578579 }) {
579 try dfw.writeByte(if (changed_reg) DW.CFA.def_cfa else DW.CFA.def_cfa_offset);
580 if (changed_reg) try dfw.writeUleb128(reg_off.reg);
581 try dfw.writeUleb128(unsigned_off.?);
580 try df_w.writeByte(if (changed_reg) DW.CFA.def_cfa else DW.CFA.def_cfa_offset);
581 if (changed_reg) try df_w.writeUleb128(reg_off.reg);
582 try df_w.writeUleb128(unsigned_off.?);
582583 } else {
583 try dfw.writeByte(if (changed_reg) DW.CFA.def_cfa_sf else DW.CFA.def_cfa_offset_sf);
584 if (changed_reg) try dfw.writeUleb128(reg_off.reg);
585 try dfw.writeSleb128(
584 try df_w.writeByte(if (changed_reg) DW.CFA.def_cfa_sf else DW.CFA.def_cfa_offset_sf);
585 if (changed_reg) try df_w.writeUleb128(reg_off.reg);
586 try df_w.writeSleb128(
586587 @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor),
587588 );
588589 }
589590 wip_nav.cfi.cfa = reg_off;
590591 },
591592 .def_cfa_expression => |expr| {
592 try dfw.writeByte(DW.CFA.def_cfa_expression);
593 try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, expr);
593 try df_w.writeByte(DW.CFA.def_cfa_expression);
594 try wip_nav.dwarf.exprLoc(df_nw, expr);
594595 },
595596 .expression => |reg_expr| {
596 try dfw.writeByte(DW.CFA.expression);
597 try dfw.writeUleb128(reg_expr.reg);
598 try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, reg_expr.expr);
597 try df_w.writeByte(DW.CFA.expression);
598 try df_w.writeUleb128(reg_expr.reg);
599 try wip_nav.dwarf.exprLoc(df_nw, reg_expr.expr);
599600 },
600601 .val_offset => |reg_off| {
601602 const factored_off =
602603 @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor);
603604 if (std.math.cast(u63, factored_off)) |unsigned_off| {
604 try dfw.writeByte(DW.CFA.val_offset);
605 try dfw.writeUleb128(reg_off.reg);
606 try dfw.writeUleb128(unsigned_off);
605 try df_w.writeByte(DW.CFA.val_offset);
606 try df_w.writeUleb128(reg_off.reg);
607 try df_w.writeUleb128(unsigned_off);
607608 } else {
608 try dfw.writeByte(DW.CFA.val_offset_sf);
609 try dfw.writeUleb128(reg_off.reg);
610 try dfw.writeSleb128(factored_off);
609 try df_w.writeByte(DW.CFA.val_offset_sf);
610 try df_w.writeUleb128(reg_off.reg);
611 try df_w.writeSleb128(factored_off);
611612 }
612613 },
613614 .val_expression => |reg_expr| {
614 try dfw.writeByte(DW.CFA.val_expression);
615 try dfw.writeUleb128(reg_expr.reg);
616 try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, reg_expr.expr);
615 try df_w.writeByte(DW.CFA.val_expression);
616 try df_w.writeUleb128(reg_expr.reg);
617 try wip_nav.dwarf.exprLoc(df_nw, reg_expr.expr);
617618 },
618 .escape => |bytes| try dfw.writeAll(bytes),
619 .escape => |bytes| try df_w.writeAll(bytes),
619620 }
620621 }
621622};
......@@ -679,15 +680,15 @@ pub const WipNav = struct {
679680 const target = &zf.mod.?.resolved_target.result;
680681 const decl = zf.zir.?.getDeclaration(inst_info.inst);
681682 const di_nw = &debug.info_writer;
682 const diw = &di_nw.interface;
683 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_func));
683 const di_w = &di_nw.interface;
684 try dwarf.abbrevCode(di_nw, .decl_func);
684685 try dwarf.refType(pt, di_nw, .fromInterned(ip.namespacePtr(switch (func.generic_owner) {
685686 .none => nav,
686687 else => |generic_owner| ip.getNav(zcu.funcInfo(generic_owner).owner_nav),
687688 }.analysis.?.namespace).owner_type));
688 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
689 try diw.writeUleb128(decl.src_column + 1);
690 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
689 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
690 try di_w.writeUleb128(decl.src_column + 1);
691 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
691692 try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip));
692693 try dwarf.strp(&dwarf.debug_str, di_nw, switch (decl.linkage) {
693694 .normal => nav.fqn,
......@@ -695,13 +696,13 @@ pub const WipNav = struct {
695696 }.toSlice(ip));
696697 try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type));
697698 try dwarf.addrSym(di_nw, debug.wip_nav.func_si, 0);
698 debug.info_func_length_offset = diw.end;
699 try diw.writeInt(u32, undefined, dwarf.endian);
700 try diw.writeUleb128(
699 debug.info_func_length_offset = di_w.end;
700 try di_w.writeInt(u32, undefined, dwarf.endian);
701 try di_w.writeUleb128(
701702 target_info.minFunctionAlignment(target).max(nav.resolved.?.@"align").toByteUnits().?,
702703 );
703 try diw.writeByte(@intFromBool(decl.linkage != .normal));
704 try diw.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu)));
704 try di_w.writeByte(@intFromBool(decl.linkage != .normal));
705 try di_w.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu)));
705706 }
706707
707708 pub fn startDebugLine(debug: *Debug) link.Error!void {
......@@ -719,29 +720,30 @@ pub const WipNav = struct {
719720 const inst_info = ip.getNav(func.owner_nav).srcInst(ip).resolveFull(ip).?;
720721 const zf = zcu.fileByIndex(inst_info.file);
721722 const decl = zf.zir.?.getDeclaration(inst_info.inst);
722 const dlw = &debug.line_writer.interface;
723 try dlw.writeByte(DW.LNS.extended_op);
723 const dl_nw = &debug.line_writer;
724 const dl_w = &dl_nw.interface;
725 try dl_w.writeByte(DW.LNS.extended_op);
724726 if (zcu.comp.config.incremental) {
725 try dlw.writeUleb128(1 + dwarf.secOffsetSize());
726 try dlw.writeByte(DW.LNE.ZIG_set_decl);
727 try dwarf.secOffset(&debug.line_writer, debug.info_writer.ni, 0);
727 try dl_w.writeUleb128(1 + dwarf.secOffsetSize());
728 try dl_w.writeByte(DW.LNE.ZIG_set_decl);
729 try dwarf.secOffset(dl_nw, debug.info_writer.ni, 0);
728730
729 try dlw.writeByte(DW.LNS.set_column);
730 try dlw.writeUleb128(func.lbrace_column + 1);
731 try dl_w.writeByte(DW.LNS.set_column);
732 try dl_w.writeUleb128(func.lbrace_column + 1);
731733
732734 try debug.advanceLineAndPc(func.lbrace_line, 0, false);
733735 } else {
734 try dlw.writeUleb128(1 + @backingInt(dwarf.address_size));
735 try dlw.writeByte(DW.LNE.set_address);
736 try dwarf.addrSym(&debug.line_writer, debug.wip_nav.func_si, 0);
736 try dl_w.writeUleb128(1 + @backingInt(dwarf.address_size));
737 try dl_w.writeByte(DW.LNE.set_address);
738 try dwarf.addrSym(dl_nw, debug.wip_nav.func_si, 0);
737739
738740 const unit = dwarf.getUnit(zf.mod.?);
739741 _, const fi = try unit.get(dwarf).getFile(zcu.gpa, unit, inst_info.file);
740 try dlw.writeByte(DW.LNS.set_file);
741 try dlw.writeUleb128(@backingInt(fi));
742 try dl_w.writeByte(DW.LNS.set_file);
743 try dl_w.writeUleb128(@backingInt(fi));
742744
743 try dlw.writeByte(DW.LNS.set_column);
744 try dlw.writeUleb128(func.lbrace_column + 1);
745 try dl_w.writeByte(DW.LNS.set_column);
746 try dl_w.writeUleb128(func.lbrace_column + 1);
745747
746748 try debug.advanceLineAndPc(decl.src_line + func.lbrace_line, 0, false);
747749 }
......@@ -749,30 +751,31 @@ pub const WipNav = struct {
749751
750752 pub fn finishFunc(debug: *Debug, func_length: u64) link.Error!void {
751753 assert(debug.wip_nav.func != .none);
754 const di_nw = &debug.info_writer;
752755 debug.finishDebugInfo(func_length) catch |err| switch (err) {
753 error.WriteFailed => return debug.wip_nav.dwarf.reportWriteError(&debug.info_writer),
756 error.WriteFailed => return debug.wip_nav.dwarf.reportWriteError(di_nw),
754757 else => |e| return e,
755758 };
756759 debug.finishDebugLine() catch |err| switch (err) {
757 error.WriteFailed => return debug.wip_nav.dwarf.reportWriteError(&debug.line_writer),
760 error.WriteFailed => return debug.wip_nav.dwarf.reportWriteError(di_nw),
758761 else => |e| return e,
759762 };
760763 }
761764 fn finishDebugInfo(debug: *Debug, func_length: u64) link.EmitError!void {
762765 const dwarf = debug.wip_nav.dwarf;
763 const diw = &debug.info_writer.interface;
766 const di_w = &debug.info_writer.interface;
764767 std.mem.writeInt(
765768 u32,
766 diw.buffered()[debug.info_func_length_offset..][0..4],
769 di_w.buffered()[debug.info_func_length_offset..][0..4],
767770 @intCast(func_length),
768771 dwarf.endian,
769772 );
770 try diw.writeUleb128(@backingInt(AbbrevCode.null));
771 try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen());
773 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
774 try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen());
772775 }
773776 fn finishDebugLine(debug: *Debug) link.EmitError!void {
774 const dlw = &debug.line_writer.interface;
775 try genDebugLinePadding(dlw, dlw.unusedCapacityLen());
777 const dl_w = &debug.line_writer.interface;
778 try genDebugLinePadding(dl_w, dl_w.unusedCapacityLen());
776779 }
777780
778781 pub const LocalVarTag = enum { arg, local_var };
......@@ -798,13 +801,13 @@ pub const WipNav = struct {
798801 assert(debug.wip_nav.func != .none);
799802 const dwarf = debug.wip_nav.dwarf;
800803 const di_nw = &debug.info_writer;
801 try di_nw.interface.writeUleb128(try dwarf.refAbbrevCode(switch (tag) {
804 try dwarf.abbrevCode(di_nw, switch (tag) {
802805 .arg => if (opt_name) |_| .arg else .unnamed_arg,
803806 .local_var => if (opt_name) |_| .local_var else unreachable,
804 }));
807 });
805808 if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name);
806809 try dwarf.refType(debug.pt, di_nw, ty);
807 try dwarf.exprLoc(&debug.info_writer, loc);
810 try dwarf.exprLoc(di_nw, loc);
808811 debug.any_children = true;
809812 }
810813
......@@ -833,7 +836,7 @@ pub const WipNav = struct {
833836 const ty = val.typeOf(zcu);
834837 const ty_class = ty.classify(zcu);
835838 const di_nw = &debug.info_writer;
836 try di_nw.interface.writeUleb128(try dwarf.refAbbrevCode(switch (tag) {
839 try dwarf.abbrevCode(di_nw, switch (tag) {
837840 .comptime_arg => if (opt_name) |_| switch (ty_class) {
838841 .no_possible_value => unreachable,
839842 .one_possible_value => .comptime_arg,
......@@ -854,7 +857,7 @@ pub const WipNav = struct {
854857 .partially_comptime => .local_const_partially_comptime,
855858 .fully_comptime => .local_const_fully_comptime,
856859 } else unreachable,
857 }));
860 });
858861 if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name);
859862 try dwarf.refType(pt, di_nw, ty);
860863 if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, val);
......@@ -870,7 +873,7 @@ pub const WipNav = struct {
870873 }
871874 fn genVarArgsDebugInfoInner(debug: *Debug) link.EmitError!void {
872875 assert(debug.wip_nav.func != .none);
873 try debug.info_writer.interface.writeUleb128(try debug.wip_nav.dwarf.refAbbrevCode(.is_var_args));
876 try debug.wip_nav.dwarf.abbrevCode(&debug.info_writer, .is_var_args);
874877 debug.any_children = true;
875878 }
876879
......@@ -890,7 +893,7 @@ pub const WipNav = struct {
890893 delta_pc: u64,
891894 end: bool,
892895 ) std.Io.Writer.Error!void {
893 const dlw = &debug.line_writer.interface;
896 const dl_w = &debug.line_writer.interface;
894897
895898 const header = debug.wip_nav.dwarf.debug_line.header;
896899 assert(header.maximum_operations_per_instruction == 1);
......@@ -900,8 +903,8 @@ pub const WipNav = struct {
900903 delta_line - header.line_base >= header.line_range)
901904 remaining: {
902905 assert(delta_line != 0);
903 try dlw.writeByte(DW.LNS.advance_line);
904 try dlw.writeSleb128(delta_line);
906 try dl_w.writeByte(DW.LNS.advance_line);
907 try dl_w.writeSleb128(delta_line);
905908 break :remaining 0;
906909 } else delta_line);
907910
......@@ -912,26 +915,26 @@ pub const WipNav = struct {
912915 op_advance >= 2 * max_op_advance)
913916 remaining: {
914917 if (op_advance == max_op_advance) {
915 try dlw.writeByte(DW.LNS.const_add_pc);
918 try dl_w.writeByte(DW.LNS.const_add_pc);
916919 } else if (op_advance != 0) {
917 try dlw.writeByte(DW.LNS.advance_pc);
918 try dlw.writeUleb128(op_advance);
920 try dl_w.writeByte(DW.LNS.advance_pc);
921 try dl_w.writeUleb128(op_advance);
919922 } else assert(end);
920923 break :remaining 0;
921924 } else if (op_advance >= max_op_advance) remaining: {
922 try dlw.writeByte(DW.LNS.const_add_pc);
925 try dl_w.writeByte(DW.LNS.const_add_pc);
923926 break :remaining op_advance - max_op_advance;
924927 } else op_advance);
925928
926929 if (remaining_delta_line != 0 or remaining_op_advance != 0) {
927930 assert(!end);
928 try dlw.writeByte(@intCast((remaining_delta_line - header.line_base) +
931 try dl_w.writeByte(@intCast((remaining_delta_line - header.line_base) +
929932 (header.line_range * remaining_op_advance) + header.opcode_base));
930933 } else if (end) {
931 try dlw.writeByte(DW.LNS.extended_op);
932 try dlw.writeUleb128(1);
933 try dlw.writeByte(DW.LNE.end_sequence);
934 } else try dlw.writeByte(DW.LNS.copy);
934 try dl_w.writeByte(DW.LNS.extended_op);
935 try dl_w.writeUleb128(1);
936 try dl_w.writeByte(DW.LNE.end_sequence);
937 } else try dl_w.writeByte(DW.LNS.copy);
935938 }
936939
937940 pub fn setColumn(debug: *Debug, column: u32) link.Error!void {
......@@ -940,9 +943,9 @@ pub const WipNav = struct {
940943 };
941944 }
942945 fn setColumnInner(debug: *Debug, column: u32) std.Io.Writer.Error!void {
943 const dlw = &debug.line_writer.interface;
944 try dlw.writeByte(DW.LNS.set_column);
945 try dlw.writeUleb128(column + 1);
946 const dl_w = &debug.line_writer.interface;
947 try dl_w.writeByte(DW.LNS.set_column);
948 try dl_w.writeUleb128(column + 1);
946949 }
947950
948951 pub fn negateStmt(debug: *Debug) link.Error!void {
......@@ -982,13 +985,14 @@ pub const WipNav = struct {
982985 const dwarf = debug.wip_nav.dwarf;
983986 const block = try debug.blocks.addOne(dwarf.lf.comp.gpa);
984987
985 const diw = &debug.info_writer.interface;
986 block.abbrev_code = @intCast(diw.end);
987 try diw.writeUleb128(try dwarf.refAbbrevCode(.block));
988 const di_nw = &debug.info_writer;
989 const di_w = &di_nw.interface;
990 block.abbrev_code = @intCast(di_w.end);
991 try dwarf.abbrevCode(di_nw, .block);
988992 block.low_pc_off = code_off;
989 try dwarf.addrSym(&debug.info_writer, debug.wip_nav.func_si, code_off);
990 block.high_pc = @intCast(diw.end);
991 try diw.writeInt(u32, 0, dwarf.endian);
993 try dwarf.addrSym(di_nw, debug.wip_nav.func_si, code_off);
994 block.high_pc = @intCast(di_w.end);
995 try di_w.writeInt(u32, 0, dwarf.endian);
992996 debug.any_children = false;
993997 }
994998
......@@ -1002,17 +1006,20 @@ pub const WipNav = struct {
10021006 const dwarf = debug.wip_nav.dwarf;
10031007 const block_size = comptime uleb128Size(@backingInt(AbbrevCode.block));
10041008 const block = debug.blocks.pop().?;
1009
1010 const di_nw = &debug.info_writer;
1011 const di_w = &di_nw.interface;
10051012 if (debug.any_children)
1006 try debug.info_writer.interface.writeUleb128(@backingInt(AbbrevCode.null))
1013 try di_w.writeUleb128(@backingInt(AbbrevCode.null))
10071014 else
10081015 std.leb.writeUnsignedFixed(
10091016 block_size,
1010 debug.info_writer.interface.buffered()[block.abbrev_code..][0..block_size],
1011 @intCast(try dwarf.refAbbrevCode(.empty_block)),
1017 di_w.buffered()[block.abbrev_code..][0..block_size],
1018 @intCast(try dwarf.refAbbrevCode(di_nw.mf, .empty_block)),
10121019 );
10131020 std.mem.writeInt(
10141021 u32,
1015 debug.info_writer.interface.buffered()[block.high_pc..][0..4],
1022 di_nw.interface.buffered()[block.high_pc..][0..4],
10161023 @intCast(code_off - block.low_pc_off),
10171024 dwarf.endian,
10181025 );
......@@ -1042,20 +1049,21 @@ pub const WipNav = struct {
10421049 const zcu = debug.pt.zcu;
10431050 const block = try debug.blocks.addOne(zcu.gpa);
10441051
1045 const diw = &debug.info_writer.interface;
1046 block.abbrev_code = @intCast(diw.end);
1047 try diw.writeUleb128(try dwarf.refAbbrevCode(.inlined_func));
1052 const di_nw = &debug.info_writer;
1053 const di_w = &di_nw.interface;
1054 block.abbrev_code = @intCast(di_w.end);
1055 try dwarf.abbrevCode(di_nw, .inlined_func);
10481056 try debug.refFunc(func);
1049 try diw.writeUleb128((if (zcu.comp.config.incremental)
1057 try di_w.writeUleb128((if (zcu.comp.config.incremental)
10501058 0
10511059 else
10521060 zcu.navSrcLine(zcu.funcInfo(debug.wip_nav.func).owner_nav) + 1) + line);
1053 try diw.writeUleb128(line);
1054 try diw.writeUleb128(column + 1);
1061 try di_w.writeUleb128(line);
1062 try di_w.writeUleb128(column + 1);
10551063 block.low_pc_off = code_off;
1056 try dwarf.addrSym(&debug.info_writer, debug.wip_nav.func_si, code_off);
1057 block.high_pc = @intCast(diw.end);
1058 try diw.writeInt(u32, 0, dwarf.endian);
1064 try dwarf.addrSym(di_nw, debug.wip_nav.func_si, code_off);
1065 block.high_pc = @intCast(di_w.end);
1066 try di_w.writeInt(u32, 0, dwarf.endian);
10591067 try debug.setInlineFunc(func);
10601068 debug.any_children = false;
10611069 }
......@@ -1074,18 +1082,20 @@ pub const WipNav = struct {
10741082 const dwarf = debug.wip_nav.dwarf;
10751083 const inlined_func_size = comptime uleb128Size(@backingInt(AbbrevCode.inlined_func));
10761084 const block = debug.blocks.pop().?;
1077 const diw = &debug.info_writer.interface;
1085
1086 const di_nw = &debug.info_writer;
1087 const di_w = &di_nw.interface;
10781088 if (debug.any_children)
1079 try diw.writeUleb128(@backingInt(AbbrevCode.null))
1089 try di_w.writeUleb128(@backingInt(AbbrevCode.null))
10801090 else
10811091 std.leb.writeUnsignedFixed(
10821092 inlined_func_size,
1083 diw.buffered()[block.abbrev_code..][0..inlined_func_size],
1084 @intCast(try dwarf.refAbbrevCode(.empty_inlined_func)),
1093 di_w.buffered()[block.abbrev_code..][0..inlined_func_size],
1094 @intCast(try dwarf.refAbbrevCode(di_nw.mf, .empty_inlined_func)),
10851095 );
10861096 std.mem.writeInt(
10871097 u32,
1088 diw.buffered()[block.high_pc..][0..4],
1098 di_w.buffered()[block.high_pc..][0..4],
10891099 @intCast(code_off - block.low_pc_off),
10901100 dwarf.endian,
10911101 );
......@@ -1105,18 +1115,15 @@ pub const WipNav = struct {
11051115 const dwarf = debug.wip_nav.dwarf;
11061116 if (debug.wip_nav.func == func) return;
11071117
1118 const dl_nw = &debug.line_writer;
1119 const dl_w = &dl_nw.interface;
11081120 const new_owner_nav = zcu.funcInfo(func).owner_nav;
1109 const dlw = &debug.line_writer.interface;
11101121 if (zcu.comp.config.incremental) {
11111122 const new_func = try dwarf.getFunc(new_owner_nav);
1112 try dlw.writeByte(DW.LNS.extended_op);
1113 try dlw.writeUleb128(1 + dwarf.secOffsetSize());
1114 try dlw.writeByte(DW.LNE.ZIG_set_decl);
1115 try dwarf.secOffset(
1116 &debug.line_writer,
1117 new_func.get(dwarf).debug_info_ni.unwrap().?,
1118 0,
1119 );
1123 try dl_w.writeByte(DW.LNS.extended_op);
1124 try dl_w.writeUleb128(1 + dwarf.secOffsetSize());
1125 try dl_w.writeByte(DW.LNE.ZIG_set_decl);
1126 try dwarf.secOffset(dl_nw, new_func.get(dwarf).debug_info_ni.unwrap().?, 0);
11201127 return;
11211128 }
11221129
......@@ -1130,15 +1137,15 @@ pub const WipNav = struct {
11301137 _, const new_fi =
11311138 try debug.wip_nav.unit.get(dwarf).getFile(zcu.gpa, new_ui, new_inst_info.file);
11321139
1133 try dlw.writeByte(DW.LNS.set_file);
1134 try dlw.writeUleb128(@backingInt(new_fi));
1140 try dl_w.writeByte(DW.LNS.set_file);
1141 try dl_w.writeUleb128(@backingInt(new_fi));
11351142 }
11361143
11371144 const old_src_line: i33 = old_zf.zir.?.getDeclaration(old_inst_info.inst).src_line;
11381145 const new_src_line: i33 = new_zf.zir.?.getDeclaration(new_inst_info.inst).src_line;
11391146 if (new_src_line != old_src_line) {
1140 try dlw.writeByte(DW.LNS.advance_line);
1141 try dlw.writeSleb128(new_src_line - old_src_line);
1147 try dl_w.writeByte(DW.LNS.advance_line);
1148 try dl_w.writeSleb128(new_src_line - old_src_line);
11421149 }
11431150
11441151 debug.wip_nav.func = func;
......@@ -1169,32 +1176,32 @@ pub const WipNav = struct {
11691176 fn genDebugFrameHeaderInner(wip_nav: *WipNav) link.EmitError!void {
11701177 assert(wip_nav.func != .none);
11711178 const dwarf = wip_nav.dwarf;
1172 const dfw = &wip_nav.fde_writer.interface;
1173 try dwarf.genUnitLength(dfw);
1179 const df_nw = &wip_nav.fde_writer;
1180 const df_w = &df_nw.interface;
1181 try dwarf.genUnitLength(df_w);
11741182 switch (wip_nav.frame_format) {
11751183 .eh_frame => {
1176 try dfw.writeInt(u32, undefined, dwarf.endian);
1184 try df_w.writeInt(u32, undefined, dwarf.endian);
11771185 {
1178 const offset = dfw.end;
1179 try dfw.writeInt(u32, 0, dwarf.endian);
1180 const elf = dwarf.lf.cast(.elf2).?;
1181 try elf.addReloc(
1182 @bitCast(wip_nav.fde_writer.ni),
1186 const offset = df_w.end;
1187 try df_w.writeInt(u32, 0, dwarf.endian);
1188 if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc(
1189 @bitCast(df_nw.ni),
11831190 offset,
11841191 wip_nav.func_si,
11851192 0,
11861193 .rel32(elf),
1187 );
1194 ) else unreachable;
11881195 }
1189 wip_nav.frame_func_length = .{ .offset = dfw.end, .size = .@"32" };
1190 try dfw.writeInt(u32, undefined, dwarf.endian);
1191 try dfw.writeUleb128(0);
1196 wip_nav.frame_func_length = .{ .offset = df_w.end, .size = .@"32" };
1197 try df_w.writeInt(u32, undefined, dwarf.endian);
1198 try df_w.writeUleb128(0);
11921199 },
11931200 .debug_frame => {
1194 try dwarf.secOffset(&wip_nav.fde_writer, wip_nav.unit.get(dwarf).cie_ni.unwrap().?, 0);
1195 try dwarf.addrSym(&wip_nav.fde_writer, wip_nav.func_si, 0);
1196 wip_nav.frame_func_length = .{ .offset = dfw.end, .size = dwarf.address_size };
1197 try dwarf.addrPlaceholder(dfw);
1201 try dwarf.secOffset(df_nw, wip_nav.unit.get(dwarf).cie_ni.unwrap().?, 0);
1202 try dwarf.addrSym(df_nw, wip_nav.func_si, 0);
1203 wip_nav.frame_func_length = .{ .offset = df_w.end, .size = dwarf.address_size };
1204 try dwarf.addrPlaceholder(df_w);
11981205 },
11991206 }
12001207 }
......@@ -1214,23 +1221,23 @@ pub const WipNav = struct {
12141221
12151222 pub fn finishDebugFrameFde(wip_nav: *WipNav, func_length: u64) void {
12161223 const dwarf = wip_nav.dwarf;
1217 const dfw = &wip_nav.fde_writer.interface;
1224 const df_w = &wip_nav.fde_writer.interface;
12181225 switch (wip_nav.frame_func_length.size) {
12191226 _ => unreachable,
12201227 .@"32" => std.mem.writeInt(
12211228 u32,
1222 dfw.buffered()[wip_nav.frame_func_length.offset..][0..4],
1229 df_w.buffered()[wip_nav.frame_func_length.offset..][0..4],
12231230 @intCast(func_length),
12241231 dwarf.endian,
12251232 ),
12261233 .@"64" => std.mem.writeInt(
12271234 u64,
1228 dfw.buffered()[wip_nav.frame_func_length.offset..][0..8],
1235 df_w.buffered()[wip_nav.frame_func_length.offset..][0..8],
12291236 func_length,
12301237 dwarf.endian,
12311238 ),
12321239 }
1233 @memset(dfw.unusedCapacitySlice(), DW.CFA.nop);
1240 @memset(df_w.unusedCapacitySlice(), DW.CFA.nop);
12341241 }
12351242};
12361243
......@@ -1596,32 +1603,31 @@ pub fn genEhFrameHdr(
15961603 .table_enc = .omit,
15971604 .eh_frame_ptr = undefined,
15981605 };
1599 const elf = dwarf.lf.cast(.elf2).?;
1600 try elf.addReloc(
1606 if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc(
16011607 eh_frame_hdr_ai,
16021608 @offsetOf(EhFrameHdr, "eh_frame_ptr"),
16031609 eh_frame_si,
16041610 0,
16051611 .rel32(elf),
1606 );
1612 ) else unreachable;
16071613}
16081614
16091615pub fn genDebugFrameCie(
16101616 dwarf: *Dwarf,
1611 dfw: *std.Io.Writer,
1617 df_w: *std.Io.Writer,
16121618 /// `null` means to generate an architecture-agnostic padding cie
16131619 arch: ?std.Target.Cpu.Arch,
16141620 format: Frame.Format,
16151621) std.Io.Writer.Error!void {
1616 try dwarf.genUnitLength(dfw);
1622 try dwarf.genUnitLength(df_w);
16171623 switch (format) {
1618 .eh_frame => try dfw.writeInt(u32, 0, dwarf.endian),
1624 .eh_frame => try df_w.writeInt(u32, 0, dwarf.endian),
16191625 .debug_frame => switch (dwarf.format) {
1620 .@"32" => try dfw.writeInt(u32, std.math.maxInt(u32), dwarf.endian),
1621 .@"64" => try dfw.writeInt(u64, std.math.maxInt(u64), dwarf.endian),
1626 .@"32" => try df_w.writeInt(u32, std.math.maxInt(u32), dwarf.endian),
1627 .@"64" => try df_w.writeInt(u64, std.math.maxInt(u64), dwarf.endian),
16221628 },
16231629 }
1624 try dfw.writeByte(if (arch) |_| switch (format) {
1630 try df_w.writeByte(if (arch) |_| switch (format) {
16251631 .eh_frame => 1,
16261632 .debug_frame => 4,
16271633 } else 0);
......@@ -1631,34 +1637,34 @@ pub fn genDebugFrameCie(
16311637 dev.check(.x86_64_backend);
16321638 const Register = @import("../codegen/x86_64/bits.zig").Register;
16331639 switch (format) {
1634 .eh_frame => try dfw.writeAll("zR\x00"),
1640 .eh_frame => try df_w.writeAll("zR\x00"),
16351641 .debug_frame => {
1636 try dfw.writeAll("\x00");
1637 try dfw.writeByte(@backingInt(dwarf.address_size));
1638 try dfw.writeByte(0);
1642 try df_w.writeAll("\x00");
1643 try df_w.writeByte(@backingInt(dwarf.address_size));
1644 try df_w.writeByte(0);
16391645 },
16401646 }
1641 try dfw.writeUleb128(dwarf.frame.header.code_alignment_factor);
1642 try dfw.writeSleb128(dwarf.frame.header.data_alignment_factor);
1647 try df_w.writeUleb128(dwarf.frame.header.code_alignment_factor);
1648 try df_w.writeSleb128(dwarf.frame.header.data_alignment_factor);
16431649 switch (format) {
1644 .eh_frame => try dfw.writeByte(@intCast(dwarf.frame.header.return_address_register)),
1645 .debug_frame => try dfw.writeUleb128(dwarf.frame.header.return_address_register),
1650 .eh_frame => try df_w.writeByte(@intCast(dwarf.frame.header.return_address_register)),
1651 .debug_frame => try df_w.writeUleb128(dwarf.frame.header.return_address_register),
16461652 }
16471653 switch (format) {
16481654 .eh_frame => {
1649 try dfw.writeUleb128(1);
1650 try dfw.writeByte(@bitCast(@as(DW.EH.PE, .{ .type = .sdata4, .rel = .pcrel })));
1655 try df_w.writeUleb128(1);
1656 try df_w.writeByte(@bitCast(@as(DW.EH.PE, .{ .type = .sdata4, .rel = .pcrel })));
16511657 },
16521658 .debug_frame => {},
16531659 }
1654 try dfw.writeByte(DW.CFA.def_cfa_sf);
1655 try dfw.writeUleb128(Register.rsp.dwarfNum());
1656 try dfw.writeSleb128(-1);
1657 try dfw.writeByte(@as(u8, DW.CFA.offset) + Register.rip.dwarfNum());
1658 try dfw.writeUleb128(1);
1660 try df_w.writeByte(DW.CFA.def_cfa_sf);
1661 try df_w.writeUleb128(Register.rsp.dwarfNum());
1662 try df_w.writeSleb128(-1);
1663 try df_w.writeByte(@as(u8, DW.CFA.offset) + Register.rip.dwarfNum());
1664 try df_w.writeUleb128(1);
16591665 },
16601666 }
1661 @memset(dfw.unusedCapacitySlice(), DW.CFA.nop);
1667 @memset(df_w.unusedCapacitySlice(), DW.CFA.nop);
16621668}
16631669
16641670pub fn updateEhFrameFde(dwarf: *Dwarf, fde: []u8, fde_offset: u64) void {
......@@ -1679,16 +1685,16 @@ pub fn genDebugInfoHeader(
16791685 dih_nw: *MappedFile.Node.Writer,
16801686) link.EmitError!void {
16811687 const comp = zcu.comp;
1682 const dihw = &dih_nw.interface;
1683 if (!unit.alive) return dwarf.genUnitPadding(dihw);
1684 try dwarf.genUnitLength(dihw);
1685 try dihw.writeInt(u16, 5, dwarf.endian);
1686 try dihw.writeByte(DW.UT.compile);
1687 try dihw.writeByte(@backingInt(dwarf.address_size));
1688 const dih_w = &dih_nw.interface;
1689 if (!unit.alive) return dwarf.genUnitPadding(dih_w);
1690 try dwarf.genUnitLength(dih_w);
1691 try dih_w.writeInt(u16, 5, dwarf.endian);
1692 try dih_w.writeByte(DW.UT.compile);
1693 try dih_w.writeByte(@backingInt(dwarf.address_size));
16881694 try dwarf.secOffset(dih_nw, dwarf.debug_abbrev.ni.unwrap().?, 0);
1689 const compile_unit_offset = dihw.end;
1690 try dihw.writeUleb128(try dwarf.refAbbrevCode(.compile_unit));
1691 try dihw.writeByte(DW.LANG.Zig);
1695 const compile_unit_offset = dih_w.end;
1696 try dwarf.abbrevCode(dih_nw, .compile_unit);
1697 try dih_w.writeByte(DW.LANG.Zig);
16921698 try dwarf.strp(&dwarf.debug_str, dih_nw, "zig " ++ @import("build_options").version);
16931699 const root_dir_path = try mod.root.toAbsolute(&comp.dirs, comp.gpa);
16941700 defer comp.gpa.free(root_dir_path);
......@@ -1701,11 +1707,11 @@ pub fn genDebugInfoHeader(
17011707 );
17021708 try dwarf.secOffset(dih_nw, unit.debug_line_header_ni.unwrap().?, 0);
17031709 try dwarf.secOffset(dih_nw, unit.debug_rnglists_ni.unwrap().?, Rnglists.offsetsTableOffset(dwarf));
1704 try dihw.writeUleb128(0);
1705 const module_offset = dihw.end;
1706 try dihw.writeUleb128(try dwarf.refAbbrevCode(.module));
1710 try dih_w.writeUleb128(0);
1711 const module_offset = dih_w.end;
1712 try dwarf.abbrevCode(dih_nw, .module);
17071713 try dwarf.strp(&dwarf.debug_str, dih_nw, mod.fully_qualified_name);
1708 try dihw.writeUleb128(0);
1714 try dih_w.writeUleb128(0);
17091715 try dwarf.genModuleDependency(
17101716 dih_nw,
17111717 "builtin",
......@@ -1716,8 +1722,8 @@ pub fn genDebugInfoHeader(
17161722 try dwarf.genModuleDependency(dih_nw, "std", zcu.std_mod, module_offset);
17171723 for (mod.deps.keys(), mod.deps.values()) |name, dep|
17181724 try dwarf.genModuleDependency(dih_nw, name, dep, module_offset);
1719 for ([2]AbbrevCode{ .pad_1, .pad_n }) |pad| _ = try dwarf.refAbbrevCode(pad);
1720 try dwarf.genDebugInfoPadding(dihw, dihw.unusedCapacityLen());
1725 for ([2]AbbrevCode{ .pad_1, .pad_n }) |pad| _ = try dwarf.refAbbrevCode(dih_nw.mf, pad);
1726 try dwarf.genDebugInfoPadding(dih_w, dih_w.unusedCapacityLen());
17211727}
17221728
17231729fn genModuleDependency(
......@@ -1729,27 +1735,33 @@ fn genModuleDependency(
17291735) link.EmitError!void {
17301736 const dep_unit = dwarf.getUnit(dep).get(dwarf);
17311737 if (!dep_unit.alive) return;
1732 const diw = &di_nw.interface;
1733 try diw.writeUleb128(try dwarf.refAbbrevCode(.module_dependency));
1738 try dwarf.abbrevCode(di_nw, .module_dependency);
17341739 try dwarf.strp(&dwarf.debug_str, di_nw, name);
17351740 try dwarf.secOffset(di_nw, dep_unit.debug_info_header_ni.unwrap().?, module_offset);
17361741}
17371742
1738pub fn genDebugInfoPadding(dwarf: *Dwarf, diw: *std.Io.Writer, size: u64) std.Io.Writer.Error!void {
1743pub fn genDebugInfoPadding(dwarf: *Dwarf, di_w: *std.Io.Writer, size: u64) std.Io.Writer.Error!void {
17391744 switch (size) {
17401745 0 => {},
1741 1 => try diw.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_1).?),
1746 1 => try di_w.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_1).?),
17421747 else => {
1743 const abbrev_code_offset = diw.end;
1744 try diw.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_n).?);
1745 const abbrev_code_size = diw.end - abbrev_code_offset;
1748 const abbrev_code_offset = di_w.end;
1749 try di_w.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_n).?);
1750 const abbrev_code_size = di_w.end - abbrev_code_offset;
17461751 var block_len_size: u5 = 1;
1747 while (true) switch (std.math.order(size - abbrev_code_size - block_len_size, @as(u64, 1) << 7 * block_len_size)) {
1748 .lt => break try diw.writeUleb128(size - abbrev_code_size - block_len_size),
1752 while (true) switch (std.math.order(
1753 size - abbrev_code_size - block_len_size,
1754 @as(u64, 1) << 7 * block_len_size,
1755 )) {
1756 .lt => break try di_w.writeUleb128(size - abbrev_code_size - block_len_size),
17491757 .eq => {
1750 // no length will ever work, so undercount and futz with the leb encoding to make up the missing byte
1758 // no length will ever work, so undercount and futz with
1759 // the leb encoding to make up the missing byte
17511760 block_len_size += 1;
1752 std.leb.writeUnsignedExtended(try diw.writableSlice(block_len_size), size - abbrev_code_size - block_len_size);
1761 std.leb.writeUnsignedExtended(
1762 try di_w.writableSlice(block_len_size),
1763 size - abbrev_code_size - block_len_size,
1764 );
17531765 break;
17541766 },
17551767 .gt => block_len_size += 1,
......@@ -1765,19 +1777,19 @@ pub fn genDebugLineHeader(
17651777 zcu: *Zcu,
17661778) link.EmitError!void {
17671779 const comp = zcu.comp;
1768 const dlhw = &dlh_nw.interface;
1769 try dwarf.genUnitLength(dlhw);
1770 try dlhw.writeInt(u16, 5, dwarf.endian);
1771 try dlhw.writeByte(@backingInt(dwarf.address_size));
1772 try dlhw.writeByte(0);
1773 const header_length_offset = dlhw.end;
1780 const dlh_w = &dlh_nw.interface;
1781 try dwarf.genUnitLength(dlh_w);
1782 try dlh_w.writeInt(u16, 5, dwarf.endian);
1783 try dlh_w.writeByte(@backingInt(dwarf.address_size));
1784 try dlh_w.writeByte(0);
1785 const header_length_offset = dlh_w.end;
17741786 switch (dwarf.format) {
1775 .@"32" => try dlhw.writeInt(u32, undefined, dwarf.endian),
1776 .@"64" => try dlhw.writeInt(u64, undefined, dwarf.endian),
1787 .@"32" => try dlh_w.writeInt(u32, undefined, dwarf.endian),
1788 .@"64" => try dlh_w.writeInt(u64, undefined, dwarf.endian),
17771789 }
1778 const header_start = dlhw.end;
1790 const header_start = dlh_w.end;
17791791 const StandardOpcode = DeclValEnum(DW.LNS);
1780 try dlhw.writeAll(&.{
1792 try dlh_w.writeAll(&.{
17811793 dwarf.debug_line.header.minimum_instruction_length,
17821794 dwarf.debug_line.header.maximum_operations_per_instruction,
17831795 @intFromBool(dwarf.debug_line.header.default_is_stmt),
......@@ -1785,7 +1797,7 @@ pub fn genDebugLineHeader(
17851797 dwarf.debug_line.header.line_range,
17861798 dwarf.debug_line.header.opcode_base,
17871799 });
1788 try dlhw.writeAll(std.enums.EnumArray(StandardOpcode, u8).init(.{
1800 try dlh_w.writeAll(std.enums.EnumArray(StandardOpcode, u8).init(.{
17891801 .extended_op = undefined,
17901802 .copy = 0,
17911803 .advance_pc = 1,
......@@ -1800,9 +1812,9 @@ pub fn genDebugLineHeader(
18001812 .set_epilogue_begin = 0,
18011813 .set_isa = 1,
18021814 }).values[1..dwarf.debug_line.header.opcode_base]);
1803 try dlhw.writeByte(1);
1804 try dlhw.writeUleb128(DW.LNCT.path);
1805 try dlhw.writeUleb128(DW.FORM.line_strp);
1815 try dlh_w.writeByte(1);
1816 try dlh_w.writeUleb128(DW.LNCT.path);
1817 try dlh_w.writeUleb128(DW.FORM.line_strp);
18061818 const dir_count = unit.dirs.count();
18071819 const directory_index_form: DeclValEnum(DW.FORM) = if (dir_count <= 1 << 8)
18081820 .data1
......@@ -1810,24 +1822,24 @@ pub fn genDebugLineHeader(
18101822 .data2
18111823 else
18121824 .udata;
1813 try dlhw.writeUleb128(dir_count);
1825 try dlh_w.writeUleb128(dir_count);
18141826 for (unit.dirs.keys()) |ui| {
18151827 const root_dir_path = try ui.mod(dwarf).root.toAbsolute(&zcu.comp.dirs, comp.gpa);
18161828 defer comp.gpa.free(root_dir_path);
18171829 try dwarf.strp(&dwarf.debug_line_str, dlh_nw, root_dir_path);
18181830 }
1819 try dlhw.writeByte(5);
1820 try dlhw.writeUleb128(DW.LNCT.path);
1821 try dlhw.writeUleb128(DW.FORM.line_strp);
1822 try dlhw.writeUleb128(DW.LNCT.directory_index);
1823 try dlhw.writeUleb128(@backingInt(directory_index_form));
1824 try dlhw.writeUleb128(DW.LNCT.timestamp);
1825 try dlhw.writeUleb128(DW.FORM.data8);
1826 try dlhw.writeUleb128(DW.LNCT.size);
1827 try dlhw.writeUleb128(DW.FORM.data8);
1828 try dlhw.writeUleb128(DW.LNCT.LLVM_source);
1829 try dlhw.writeUleb128(DW.FORM.line_strp);
1830 try dlhw.writeUleb128(unit.files.count());
1831 try dlh_w.writeByte(5);
1832 try dlh_w.writeUleb128(DW.LNCT.path);
1833 try dlh_w.writeUleb128(DW.FORM.line_strp);
1834 try dlh_w.writeUleb128(DW.LNCT.directory_index);
1835 try dlh_w.writeUleb128(@backingInt(directory_index_form));
1836 try dlh_w.writeUleb128(DW.LNCT.timestamp);
1837 try dlh_w.writeUleb128(DW.FORM.data8);
1838 try dlh_w.writeUleb128(DW.LNCT.size);
1839 try dlh_w.writeUleb128(DW.FORM.data8);
1840 try dlh_w.writeUleb128(DW.LNCT.LLVM_source);
1841 try dlh_w.writeUleb128(DW.FORM.line_strp);
1842 try dlh_w.writeUleb128(unit.files.count());
18311843 for (unit.files.keys()) |zfi| {
18321844 const zf = zcu.fileByIndex(zfi);
18331845 try dwarf.strp(&dwarf.debug_line_str, dlh_nw, zf.sub_file_path);
......@@ -1835,12 +1847,12 @@ pub fn genDebugLineHeader(
18351847 if (zcu.alive_files.contains(zfi)) unit.dirs.getIndex(dwarf.getUnit(zf.mod.?)).? else 0;
18361848 switch (directory_index_form) {
18371849 else => unreachable,
1838 .data1 => try dlhw.writeByte(@intCast(di)),
1839 .data2 => try dlhw.writeInt(u16, @intCast(di), dwarf.endian),
1840 .udata => try dlhw.writeUleb128(di),
1850 .data1 => try dlh_w.writeByte(@intCast(di)),
1851 .data2 => try dlh_w.writeInt(u16, @intCast(di), dwarf.endian),
1852 .udata => try dlh_w.writeUleb128(di),
18411853 }
1842 try dlhw.writeInt(i64, @truncate(zf.stat.mtime.nanoseconds), dwarf.endian);
1843 try dlhw.writeInt(u64, zf.stat.size, dwarf.endian);
1854 try dlh_w.writeInt(i64, @truncate(zf.stat.mtime.nanoseconds), dwarf.endian);
1855 try dlh_w.writeInt(u64, zf.stat.size, dwarf.endian);
18441856 try dwarf.strp(
18451857 &dwarf.debug_line_str,
18461858 dlh_nw,
......@@ -1850,41 +1862,48 @@ pub fn genDebugLineHeader(
18501862 switch (dwarf.format) {
18511863 .@"32" => std.mem.writeInt(
18521864 u32,
1853 dlhw.buffer[header_length_offset..][0..4],
1854 @intCast(dlhw.end - header_start),
1865 dlh_w.buffer[header_length_offset..][0..4],
1866 @intCast(dlh_w.end - header_start),
18551867 dwarf.endian,
18561868 ),
18571869 .@"64" => std.mem.writeInt(
18581870 u64,
1859 dlhw.buffer[header_length_offset..][0..8],
1860 dlhw.end - header_start,
1871 dlh_w.buffer[header_length_offset..][0..8],
1872 dlh_w.end - header_start,
18611873 dwarf.endian,
18621874 ),
18631875 }
1864 try genDebugLinePadding(dlhw, dlhw.unusedCapacityLen());
1876 try genDebugLinePadding(dlh_w, dlh_w.unusedCapacityLen());
18651877}
18661878
1867pub fn genDebugLinePadding(dlw: *std.Io.Writer, size: u64) std.Io.Writer.Error!void {
1879pub fn genDebugLinePadding(dl_w: *std.Io.Writer, size: u64) std.Io.Writer.Error!void {
18681880 switch (size) {
18691881 0 => {},
1870 1 => try dlw.writeByte(DW.LNS.const_add_pc),
1871 2 => try dlw.writeAll(&.{ DW.LNS.negate_stmt, DW.LNS.negate_stmt }),
1882 1 => try dl_w.writeByte(DW.LNS.const_add_pc),
1883 2 => try dl_w.writeAll(&.{ DW.LNS.negate_stmt, DW.LNS.negate_stmt }),
18721884 else => {
1873 const extended_op_offset = dlw.end;
1874 try dlw.writeByte(DW.LNS.extended_op);
1875 const extended_op_size = dlw.end - extended_op_offset;
1885 const extended_op_offset = dl_w.end;
1886 try dl_w.writeByte(DW.LNS.extended_op);
1887 const extended_op_size = dl_w.end - extended_op_offset;
18761888 var op_len_size: u5 = 1;
1877 while (true) switch (std.math.order(size - extended_op_size - op_len_size, @as(u64, 1) << 7 * op_len_size)) {
1878 .lt => break try dlw.writeUleb128(size - extended_op_size - op_len_size),
1889 while (true) switch (std.math.order(
1890 size - extended_op_size - op_len_size,
1891 @as(u64, 1) << 7 * op_len_size,
1892 )) {
1893 .lt => break try dl_w.writeUleb128(size - extended_op_size - op_len_size),
18791894 .eq => {
1880 // no length will ever work, so undercount and futz with the leb encoding to make up the missing byte
1895 // no length will ever work, so undercount and futz with
1896 // the leb encoding to make up the missing byte
18811897 op_len_size += 1;
1882 std.leb.writeUnsignedExtended(try dlw.writableSlice(op_len_size), size - extended_op_size - op_len_size);
1898 std.leb.writeUnsignedExtended(
1899 try dl_w.writableSlice(op_len_size),
1900 size - extended_op_size - op_len_size,
1901 );
18831902 break;
18841903 },
18851904 .gt => op_len_size += 1,
18861905 };
1887 try dlw.writeByte(DW.LNE.padding);
1906 try dl_w.writeByte(DW.LNE.padding);
18881907 },
18891908 }
18901909}
......@@ -1894,19 +1913,19 @@ pub fn genDebugRnglistsHeader(
18941913 unit: *Unit,
18951914 drh_nw: *MappedFile.Node.Writer,
18961915) std.Io.Writer.Error!void {
1897 const drhw = &drh_nw.interface;
1898 try dwarf.genUnitLength(drhw);
1899 try drhw.writeInt(u16, 5, dwarf.endian);
1900 try drhw.writeByte(@backingInt(dwarf.address_size));
1901 try drhw.writeByte(0);
1902 try drhw.writeInt(u32, 1, dwarf.endian);
1903 assert(drhw.end == Rnglists.offsetsTableOffset(dwarf));
1916 const drh_w = &drh_nw.interface;
1917 try dwarf.genUnitLength(drh_w);
1918 try drh_w.writeInt(u16, 5, dwarf.endian);
1919 try drh_w.writeByte(@backingInt(dwarf.address_size));
1920 try drh_w.writeByte(0);
1921 try drh_w.writeInt(u32, 1, dwarf.endian);
1922 assert(drh_w.end == Rnglists.offsetsTableOffset(dwarf));
19041923 switch (dwarf.format) {
1905 .@"32" => try drhw.writeInt(u32, 4, dwarf.endian),
1906 .@"64" => try drhw.writeInt(u64, 8, dwarf.endian),
1924 .@"32" => try drh_w.writeInt(u32, 4, dwarf.endian),
1925 .@"64" => try drh_w.writeInt(u64, 8, dwarf.endian),
19071926 }
1908 unit.debug_rnglists_end = drhw.end;
1909 try drhw.writeByte(DW.RLE.end_of_list);
1927 unit.debug_rnglists_end = drh_w.end;
1928 try drh_w.writeByte(DW.RLE.end_of_list);
19101929}
19111930
19121931pub fn genDebugRnglists(
......@@ -1916,13 +1935,13 @@ pub fn genDebugRnglists(
19161935 func_si: link.File.SymbolId,
19171936 func_length: u64,
19181937) link.EmitError!void {
1919 const drw = &dr_nw.interface;
1920 drw.end = unit.debug_rnglists_end;
1921 try drw.writeByte(DW.RLE.start_length);
1938 const dr_w = &dr_nw.interface;
1939 dr_w.end = unit.debug_rnglists_end;
1940 try dr_w.writeByte(DW.RLE.start_length);
19221941 try dwarf.addrSym(dr_nw, func_si, 0);
1923 try drw.writeUleb128(func_length);
1924 unit.debug_rnglists_end = drw.end;
1925 try drw.writeByte(DW.RLE.end_of_list);
1942 try dr_w.writeUleb128(func_length);
1943 unit.debug_rnglists_end = dr_w.end;
1944 try dr_w.writeByte(DW.RLE.end_of_list);
19261945}
19271946
19281947pub fn updateComptimeNav(
......@@ -2054,95 +2073,107 @@ fn updateConstInner(
20542073) link.EmitError!void {
20552074 const zcu = pt.zcu;
20562075 const ip = &zcu.intern_pool;
2057 const diw = &di_nw.interface;
2076 const di_w = &di_nw.interface;
20582077 switch (ip.indexToKey(val)) {
20592078 .int_type => |int_type| {
20602079 const ty: Type = .fromInterned(val);
2061 try diw.writeUleb128(try dwarf.refAbbrevCode(.numeric_type));
2080 try dwarf.abbrevCode(di_nw, .numeric_type);
20622081 var name_buf: [std.fmt.count("i{d}", .{std.math.maxInt(u16)})]u8 = undefined;
2063 try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&name_buf, "{f}", .{ty.fmt(pt)}) catch unreachable);
2064 try diw.writeByte(switch (int_type.signedness) {
2082 try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&name_buf, "{f}", .{
2083 ty.fmt(pt),
2084 }) catch unreachable);
2085 try di_w.writeByte(switch (int_type.signedness) {
20652086 .signed => DW.ATE.signed,
20662087 .unsigned => DW.ATE.unsigned,
20672088 });
2068 try diw.writeUleb128(int_type.bits);
2069 try diw.writeUleb128(ty.abiSize(zcu));
2070 try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2089 try di_w.writeUleb128(int_type.bits);
2090 try di_w.writeUleb128(ty.abiSize(zcu));
2091 try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
20712092 },
20722093 .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
20732094 .one, .many, .c => {
20742095 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
20752096 defer zcu.gpa.free(name);
2076 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (ptr_type.flags.alignment) {
2077 .none => if (ptr_type.sentinel == .none) .ptr_type else .ptr_sentinel_type,
2078 else => if (ptr_type.sentinel == .none) .ptr_aligned_type else .ptr_aligned_sentinel_type,
2079 }));
2097 try dwarf.abbrevCode(di_nw, switch (ptr_type.sentinel) {
2098 .none => switch (ptr_type.flags.alignment) {
2099 .none => .ptr_type,
2100 else => .ptr_aligned_type,
2101 },
2102 else => switch (ptr_type.flags.alignment) {
2103 .none => .ptr_sentinel_type,
2104 else => .ptr_aligned_sentinel_type,
2105 },
2106 });
20802107 try dwarf.strp(&dwarf.debug_str, di_nw, name);
2081 if (ptr_type.sentinel != .none) try dwarf.blockConst(pt, di_nw, .fromInterned(ptr_type.sentinel));
2082 if (ptr_type.flags.alignment.toByteUnits()) |a| try diw.writeUleb128(a);
2083 try diw.writeByte(@backingInt(ptr_type.flags.address_space));
2108 switch (ptr_type.sentinel) {
2109 .none => {},
2110 else => |sentinel| try dwarf.blockConst(pt, di_nw, .fromInterned(sentinel)),
2111 }
2112 if (ptr_type.flags.alignment.toByteUnits()) |a| try di_w.writeUleb128(a);
2113 try di_w.writeByte(@backingInt(ptr_type.flags.address_space));
20842114 if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try dwarf.secOffset(
20852115 di_nw,
20862116 di_nw.ni,
2087 diw.end + dwarf.secOffsetSize(),
2117 di_w.end + dwarf.secOffsetSize(),
20882118 );
20892119 if (ptr_type.flags.is_const) {
2090 try diw.writeUleb128(try dwarf.refAbbrevCode(.is_const));
2120 try dwarf.abbrevCode(di_nw, .is_const);
20912121 if (ptr_type.flags.is_volatile) try dwarf.secOffset(
20922122 di_nw,
20932123 di_nw.ni,
2094 diw.end + dwarf.secOffsetSize(),
2124 di_w.end + dwarf.secOffsetSize(),
20952125 );
20962126 }
2097 if (ptr_type.flags.is_volatile) try diw.writeUleb128(try dwarf.refAbbrevCode(.is_volatile));
2127 if (ptr_type.flags.is_volatile) try dwarf.abbrevCode(di_nw, .is_volatile);
20982128 try dwarf.refType(pt, di_nw, .fromInterned(ptr_type.child));
20992129 },
21002130 .slice => {
21012131 const ty: Type = .fromInterned(val);
21022132 const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)});
21032133 defer zcu.gpa.free(name);
2104 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_struct_type));
2134 try dwarf.abbrevCode(di_nw, .generated_struct_type);
21052135 try dwarf.strp(&dwarf.debug_str, di_nw, name);
2106 try diw.writeUleb128(ty.abiSize(zcu));
2107 try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2108 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2136 try di_w.writeUleb128(ty.abiSize(zcu));
2137 try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2138 try dwarf.abbrevCode(di_nw, .generated_field);
21092139 try dwarf.strp(&dwarf.debug_str, di_nw, "ptr");
21102140 const ptr_field_ty = ty.slicePtrFieldType(zcu);
21112141 try dwarf.refType(pt, di_nw, ptr_field_ty);
2112 try diw.writeUleb128(0);
2113 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2142 try di_w.writeUleb128(0);
2143 try dwarf.abbrevCode(di_nw, .generated_field);
21142144 try dwarf.strp(&dwarf.debug_str, di_nw, "len");
21152145 const len_field_ty: Type = .usize;
21162146 try dwarf.refType(pt, di_nw, len_field_ty);
2117 try diw.writeUleb128(len_field_ty.abiAlignment(zcu).forward(ptr_field_ty.abiSize(zcu)));
2118 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2147 try di_w.writeUleb128(len_field_ty.abiAlignment(zcu).forward(ptr_field_ty.abiSize(zcu)));
2148 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
21192149 },
21202150 },
21212151 .array_type => |array_type| {
21222152 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
21232153 defer zcu.gpa.free(name);
2124 try diw.writeUleb128(try dwarf.refAbbrevCode(
2154 try dwarf.abbrevCode(
2155 di_nw,
21252156 if (array_type.sentinel == .none) .array_type else .array_sentinel_type,
2126 ));
2157 );
21272158 try dwarf.strp(&dwarf.debug_str, di_nw, name);
21282159 if (array_type.sentinel != .none)
21292160 try dwarf.blockConst(pt, di_nw, .fromInterned(array_type.sentinel));
21302161 try dwarf.refType(pt, di_nw, .fromInterned(array_type.child));
2131 try diw.writeUleb128(try dwarf.refAbbrevCode(.array_len));
2162 try dwarf.abbrevCode(di_nw, .array_len);
21322163 try dwarf.refType(pt, di_nw, .usize);
2133 try diw.writeUleb128(array_type.len);
2134 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2164 try di_w.writeUleb128(array_type.len);
2165 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
21352166 },
21362167 .vector_type => |vector_type| {
21372168 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
21382169 defer zcu.gpa.free(name);
2139 try diw.writeUleb128(try dwarf.refAbbrevCode(.vector_type));
2170 try dwarf.abbrevCode(di_nw, .vector_type);
21402171 try dwarf.strp(&dwarf.debug_str, di_nw, name);
21412172 try dwarf.refType(pt, di_nw, .fromInterned(vector_type.child));
2142 try diw.writeUleb128(try dwarf.refAbbrevCode(.array_len));
2173 try dwarf.abbrevCode(di_nw, .array_len);
21432174 try dwarf.refType(pt, di_nw, .usize);
2144 try diw.writeUleb128(vector_type.len);
2145 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2175 try di_w.writeUleb128(vector_type.len);
2176 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
21462177 },
21472178 .opt_type => |opt_child_type_index| {
21482179 const opt_ty: Type = .fromInterned(val);
......@@ -2150,66 +2181,66 @@ fn updateConstInner(
21502181 const opt_repr = optRepr(opt_child_ty, zcu);
21512182 const name = try zcu.gpa.print("{f}", .{opt_ty.fmt(pt)});
21522183 defer zcu.gpa.free(name);
2153 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_union_type));
2184 try dwarf.abbrevCode(di_nw, .generated_union_type);
21542185 try dwarf.strp(&dwarf.debug_str, di_nw, name);
2155 try diw.writeUleb128(opt_ty.abiSize(zcu));
2156 try diw.writeUleb128(opt_ty.abiAlignment(zcu).toByteUnits().?);
2186 try di_w.writeUleb128(opt_ty.abiSize(zcu));
2187 try di_w.writeUleb128(opt_ty.abiAlignment(zcu).toByteUnits().?);
21572188 switch (opt_repr) {
21582189 .opv_null => {
2159 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2190 try dwarf.abbrevCode(di_nw, .generated_field);
21602191 try dwarf.strp(&dwarf.debug_str, di_nw, "null");
21612192 try dwarf.refType(pt, di_nw, .null);
2162 try diw.writeUleb128(0);
2193 try di_w.writeUleb128(0);
21632194 },
21642195 .unpacked, .error_set, .pointer => {
2165 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union));
2166 try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize());
2196 try dwarf.abbrevCode(di_nw, .tagged_union);
2197 try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize());
21672198 {
2168 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2199 try dwarf.abbrevCode(di_nw, .generated_field);
21692200 try dwarf.strp(&dwarf.debug_str, di_nw, "has_value");
21702201 switch (opt_repr) {
21712202 .opv_null => unreachable,
21722203 .unpacked => {
21732204 try dwarf.refType(pt, di_nw, .bool);
2174 try diw.writeUleb128(if (opt_child_ty.hasRuntimeBits(zcu))
2205 try di_w.writeUleb128(if (opt_child_ty.hasRuntimeBits(zcu))
21752206 opt_child_ty.abiSize(zcu)
21762207 else
21772208 0);
21782209 },
21792210 .error_set => {
21802211 try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits()));
2181 try diw.writeUleb128(0);
2212 try di_w.writeUleb128(0);
21822213 },
21832214 .pointer => {
21842215 try dwarf.refType(pt, di_nw, .usize);
2185 try diw.writeUleb128(0);
2216 try di_w.writeUleb128(0);
21862217 },
21872218 }
21882219
2189 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field));
2190 try diw.writeUleb128(DW.FORM.data1);
2191 try diw.writeByte(0);
2220 try dwarf.abbrevCode(di_nw, .tagged_union_field);
2221 try di_w.writeUleb128(DW.FORM.data1);
2222 try di_w.writeByte(0);
21922223 {
2193 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2224 try dwarf.abbrevCode(di_nw, .generated_field);
21942225 try dwarf.strp(&dwarf.debug_str, di_nw, "null");
21952226 try dwarf.refType(pt, di_nw, .null);
2196 try diw.writeUleb128(0);
2227 try di_w.writeUleb128(0);
21972228 }
2198 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2229 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
21992230
2200 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_default_field));
2231 try dwarf.abbrevCode(di_nw, .tagged_union_default_field);
22012232 {
2202 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2233 try dwarf.abbrevCode(di_nw, .generated_field);
22032234 try dwarf.strp(&dwarf.debug_str, di_nw, "?");
22042235 try dwarf.refType(pt, di_nw, opt_child_ty);
2205 try diw.writeUleb128(0);
2236 try di_w.writeUleb128(0);
22062237 }
2207 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2238 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22082239 }
2209 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2240 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22102241 },
22112242 }
2212 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2243 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22132244 },
22142245 .anyframe_type => unreachable,
22152246 .error_union_type => |error_union_type| {
......@@ -2226,49 +2257,49 @@ fn updateConstInner(
22262257 const name = try zcu.gpa.print("{f}", .{eu_ty.fmt(pt)});
22272258 defer zcu.gpa.free(name);
22282259
2229 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_union_type));
2260 try dwarf.abbrevCode(di_nw, .generated_union_type);
22302261 try dwarf.strp(&dwarf.debug_str, di_nw, name);
22312262 if (error_union_type.error_set_type != .generic_poison_type and
22322263 error_union_type.payload_type != .generic_poison_type)
22332264 {
2234 try diw.writeUleb128(eu_ty.abiSize(zcu));
2235 try diw.writeUleb128(eu_ty.abiAlignment(zcu).toByteUnits().?);
2265 try di_w.writeUleb128(eu_ty.abiSize(zcu));
2266 try di_w.writeUleb128(eu_ty.abiAlignment(zcu).toByteUnits().?);
22362267 } else {
2237 try diw.writeUleb128(0);
2238 try diw.writeUleb128(1);
2268 try di_w.writeUleb128(0);
2269 try di_w.writeUleb128(1);
22392270 }
22402271 {
2241 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union));
2242 try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize());
2272 try dwarf.abbrevCode(di_nw, .tagged_union);
2273 try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize());
22432274 {
2244 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2275 try dwarf.abbrevCode(di_nw, .generated_field);
22452276 try dwarf.strp(&dwarf.debug_str, di_nw, "is_error");
22462277 try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits()));
2247 try diw.writeUleb128(eu_error_set_offset);
2278 try di_w.writeUleb128(eu_error_set_offset);
22482279
2249 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field));
2250 try diw.writeUleb128(DW.FORM.udata);
2251 try diw.writeUleb128(0);
2280 try dwarf.abbrevCode(di_nw, .tagged_union_field);
2281 try di_w.writeUleb128(DW.FORM.udata);
2282 try di_w.writeUleb128(0);
22522283 {
2253 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2284 try dwarf.abbrevCode(di_nw, .generated_field);
22542285 try dwarf.strp(&dwarf.debug_str, di_nw, "value");
22552286 try dwarf.refType(pt, di_nw, eu_payload_ty);
2256 try diw.writeUleb128(eu_payload_offset);
2287 try di_w.writeUleb128(eu_payload_offset);
22572288 }
2258 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2289 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22592290
2260 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_default_field));
2291 try dwarf.abbrevCode(di_nw, .tagged_union_default_field);
22612292 {
2262 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2293 try dwarf.abbrevCode(di_nw, .generated_field);
22632294 try dwarf.strp(&dwarf.debug_str, di_nw, "error");
22642295 try dwarf.refType(pt, di_nw, eu_error_set_ty);
2265 try diw.writeUleb128(eu_error_set_offset);
2296 try di_w.writeUleb128(eu_error_set_offset);
22662297 }
2267 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2298 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22682299 }
2269 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2300 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22702301 }
2271 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2302 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
22722303 },
22732304 .simple_type => |simple_type| switch (simple_type) {
22742305 .f16,
......@@ -2291,9 +2322,9 @@ fn updateConstInner(
22912322 .bool,
22922323 => {
22932324 const ty: Type = .fromInterned(val);
2294 try diw.writeUleb128(try dwarf.refAbbrevCode(.numeric_type));
2325 try dwarf.abbrevCode(di_nw, .numeric_type);
22952326 try dwarf.strp(&dwarf.debug_str, di_nw, @tagName(simple_type));
2296 try diw.writeByte(if (val == .bool_type)
2327 try di_w.writeByte(if (val == .bool_type)
22972328 DW.ATE.boolean
22982329 else if (ty.isRuntimeFloat())
22992330 DW.ATE.float
......@@ -2303,12 +2334,12 @@ fn updateConstInner(
23032334 DW.ATE.unsigned
23042335 else
23052336 unreachable);
2306 try diw.writeUleb128(ty.bitSize(zcu));
2307 try diw.writeUleb128(ty.abiSize(zcu));
2308 try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2337 try di_w.writeUleb128(ty.bitSize(zcu));
2338 try di_w.writeUleb128(ty.abiSize(zcu));
2339 try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
23092340 },
23102341 .generic_poison => {
2311 try diw.writeUleb128(try dwarf.refAbbrevCode(.void_type));
2342 try dwarf.abbrevCode(di_nw, .void_type);
23122343 try dwarf.strp(&dwarf.debug_str, di_nw, "anytype");
23132344 },
23142345 .anyopaque,
......@@ -2322,24 +2353,27 @@ fn updateConstInner(
23222353 .enum_literal,
23232354 => {
23242355 const ty: Type = .fromInterned(val);
2325 try diw.writeUleb128(try dwarf.refAbbrevCode(.void_type));
2356 try dwarf.abbrevCode(di_nw, .void_type);
23262357 var name_buf: ["@TypeOf(undefined)".len]u8 = undefined;
2327 try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&name_buf, "{f}", .{ty.fmt(pt)}) catch unreachable);
2358 try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&name_buf, "{f}", .{
2359 ty.fmt(pt),
2360 }) catch unreachable);
23282361 },
23292362 .anyerror => {
23302363 const global_error_set_names = ip.global_error_set.getNamesFromMainThread();
2331 try diw.writeUleb128(try dwarf.refAbbrevCode(
2332 if (global_error_set_names.len > 0) .generated_enum_type else .generated_empty_enum_type,
2333 ));
2364 try dwarf.abbrevCode(di_nw, if (global_error_set_names.len > 0)
2365 .generated_enum_type
2366 else
2367 .generated_empty_enum_type);
23342368 try dwarf.strp(&dwarf.debug_str, di_nw, "anyerror");
23352369 try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits()));
23362370 for (global_error_set_names, 1..) |name, value| {
2337 try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field));
2338 try diw.writeUleb128(DW.FORM.udata);
2339 try diw.writeUleb128(value);
2371 try dwarf.abbrevCode(di_nw, .enum_field);
2372 try di_w.writeUleb128(DW.FORM.udata);
2373 try di_w.writeUleb128(value);
23402374 try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip));
23412375 }
2342 if (global_error_set_names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null));
2376 if (global_error_set_names.len > 0) try di_w.writeUleb128(@backingInt(AbbrevCode.null));
23432377 },
23442378 .adhoc_inferred_error_set => unreachable,
23452379 },
......@@ -2348,14 +2382,14 @@ fn updateConstInner(
23482382 const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)});
23492383 defer zcu.gpa.free(name);
23502384 if (tuple_type.types.len == 0) {
2351 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_empty_struct_type));
2385 try dwarf.abbrevCode(di_nw, .generated_empty_struct_type);
23522386 try dwarf.strp(&dwarf.debug_str, di_nw, name);
2353 try diw.writeByte(@intFromBool(false));
2387 try di_w.writeByte(@intFromBool(false));
23542388 } else {
2355 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_struct_type));
2389 try dwarf.abbrevCode(di_nw, .generated_struct_type);
23562390 try dwarf.strp(&dwarf.debug_str, di_nw, name);
2357 try diw.writeUleb128(ty.abiSize(zcu));
2358 try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2391 try di_w.writeUleb128(ty.abiSize(zcu));
2392 try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
23592393 var field_byte_offset: u64 = 0;
23602394 for (0..tuple_type.types.len) |field_index| {
23612395 const comptime_value = tuple_type.values.get(ip)[field_index];
......@@ -2364,7 +2398,7 @@ fn updateConstInner(
23642398 .none => .no_possible_value,
23652399 else => field_ty.classify(zcu),
23662400 };
2367 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (comptime_value) {
2401 try dwarf.abbrevCode(di_nw, switch (comptime_value) {
23682402 .none => .field,
23692403 else => switch (comptime_value_class) {
23702404 .no_possible_value, .one_possible_value => .field_comptime,
......@@ -2372,19 +2406,17 @@ fn updateConstInner(
23722406 .partially_comptime => .field_comptime_partially_comptime,
23732407 .fully_comptime => .field_comptime_fully_comptime,
23742408 },
2375 }));
2409 });
23762410 var field_name_buf: [std.fmt.count("{d}", .{std.math.maxInt(u32)})]u8 = undefined;
2377 try dwarf.strp(
2378 &dwarf.debug_str,
2379 di_nw,
2380 std.mem.print(&field_name_buf, "{d}", .{field_index}) catch unreachable,
2381 );
2411 try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&field_name_buf, "{d}", .{
2412 field_index,
2413 }) catch unreachable);
23822414 try dwarf.refType(pt, di_nw, field_ty);
23832415 if (comptime_value == .none) {
23842416 const field_align = field_ty.abiAlignment(zcu);
23852417 field_byte_offset = field_align.forward(field_byte_offset);
2386 try diw.writeUleb128(field_byte_offset);
2387 try diw.writeUleb128(field_ty.abiAlignment(zcu).toByteUnits().?);
2418 try di_w.writeUleb128(field_byte_offset);
2419 try di_w.writeUleb128(field_ty.abiAlignment(zcu).toByteUnits().?);
23882420 field_byte_offset += field_ty.abiSize(zcu);
23892421 }
23902422 if (comptime_value_class.hasRuntimeBits())
......@@ -2392,7 +2424,7 @@ fn updateConstInner(
23922424 if (comptime_value_class.comptimeOnly())
23932425 try dwarf.refConst(pt, di_nw, .fromInterned(comptime_value));
23942426 }
2395 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2427 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
23962428 }
23972429 },
23982430 .struct_type => {
......@@ -2404,22 +2436,21 @@ fn updateConstInner(
24042436 assert(loaded_struct.captures.len == 0);
24052437 const ui = dwarf.getUnit(zf.mod.?);
24062438 _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, zfi);
2407 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_struct.layout) {
2439 try dwarf.abbrevCode(di_nw, switch (loaded_struct.layout) {
24082440 .auto => if (loaded_struct.field_types.len > 0) .file else .empty_file,
24092441 .@"extern", .@"packed" => unreachable,
2410 }));
2411 try diw.writeUleb128(@backingInt(fi));
2442 });
2443 try di_w.writeUleb128(@backingInt(fi));
24122444 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip));
24132445 } else if (loaded_struct.captures.len > 0 or loaded_struct.is_reified) {
2414 try diw.writeUleb128(try dwarf.refAbbrevCode(
2415 if (loaded_struct.captures.len > 0 or loaded_struct.field_types.len > 0) switch (loaded_struct.layout) {
2416 .auto, .@"extern" => .decl_instance_struct,
2417 .@"packed" => .decl_instance_packed_struct,
2418 } else switch (loaded_struct.layout) {
2419 .auto, .@"extern" => .decl_instance_empty_struct,
2420 .@"packed" => .decl_instance_empty_packed_struct,
2421 },
2422 ));
2446 try dwarf.abbrevCode(di_nw, if (loaded_struct.captures.len > 0 or
2447 loaded_struct.field_types.len > 0) switch (loaded_struct.layout) {
2448 .auto, .@"extern" => .decl_instance_struct,
2449 .@"packed" => .decl_instance_packed_struct,
2450 } else switch (loaded_struct.layout) {
2451 .auto, .@"extern" => .decl_instance_empty_struct,
2452 .@"packed" => .decl_instance_empty_packed_struct,
2453 });
24232454 try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0);
24242455 } else if (loaded_struct.name_nav.unwrap()) |name_ni| {
24252456 const name_nav = ip.getNav(name_ni);
......@@ -2427,34 +2458,44 @@ fn updateConstInner(
24272458 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
24282459 name_nav.analysis.?.namespace,
24292460 ).owner_type);
2430 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_struct.layout) {
2431 .auto, .@"extern" => if (loaded_struct.field_types.len > 0) .decl_struct else .decl_empty_struct,
2432 .@"packed" => if (loaded_struct.field_types.len > 0) .decl_packed_struct else .decl_empty_packed_struct,
2433 }));
2461 try dwarf.abbrevCode(di_nw, if (loaded_struct.field_types.len > 0)
2462 switch (loaded_struct.layout) {
2463 .auto, .@"extern" => .decl_struct,
2464 .@"packed" => .decl_packed_struct,
2465 }
2466 else switch (loaded_struct.layout) {
2467 .auto, .@"extern" => .decl_empty_struct,
2468 .@"packed" => .decl_empty_packed_struct,
2469 });
24342470 try dwarf.secOffset(di_nw, parent_ni, 0);
2435 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2436 try diw.writeUleb128(decl.src_column + 1);
2437 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
2471 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2472 try di_w.writeUleb128(decl.src_column + 1);
2473 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
24382474 try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip));
24392475 } else {
24402476 const decl = zf.zir.?.getStructDecl(src_inst.?);
24412477 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
24422478 ip.namespacePtr(loaded_struct.namespace).parent.unwrap().?,
24432479 ).owner_type);
2444 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_struct.layout) {
2445 .auto, .@"extern" => if (loaded_struct.field_types.len > 0) .type_decl_struct else .type_decl_empty_struct,
2446 .@"packed" => if (loaded_struct.field_types.len > 0) .type_decl_packed_struct else .type_decl_empty_packed_struct,
2447 }));
2480 try dwarf.abbrevCode(di_nw, if (loaded_struct.field_types.len > 0)
2481 switch (loaded_struct.layout) {
2482 .auto, .@"extern" => .type_decl_struct,
2483 .@"packed" => .type_decl_packed_struct,
2484 }
2485 else switch (loaded_struct.layout) {
2486 .auto, .@"extern" => .type_decl_empty_struct,
2487 .@"packed" => .type_decl_empty_packed_struct,
2488 });
24482489 try dwarf.secOffset(di_nw, parent_ni, 0);
2449 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2450 try diw.writeUleb128(decl.src_column + 1);
2490 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2491 try di_w.writeUleb128(decl.src_column + 1);
24512492 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip));
24522493 }
24532494 switch (loaded_struct.layout) {
24542495 .auto, .@"extern" => {
24552496 const ty: Type = .fromInterned(val);
2456 try diw.writeUleb128(ty.abiSize(zcu));
2457 try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
2497 try di_w.writeUleb128(ty.abiSize(zcu));
2498 try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?);
24582499 try dwarf.genCaptures(pt, di_nw, loaded_struct.captures);
24592500 for (0..loaded_struct.field_types.len) |field_index| {
24602501 const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index);
......@@ -2466,26 +2507,40 @@ fn updateConstInner(
24662507 // indicate completion of the type's layout, a task should be enqueued
24672508 // by `Zcu.PerThread.ensureStructDefaultsUpToDate`, and upon receiving
24682509 // it we should patch the correct default field values in.
2469 const field_default: InternPool.Index =
2470 if (is_comptime) loaded_struct.field_defaults.getOrNone(ip, field_index) else .none;
2510 const field_default = if (is_comptime)
2511 loaded_struct.field_defaults.getOrNone(ip, field_index)
2512 else
2513 .none;
24712514 assert(!(is_comptime and field_default == .none));
2472 const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
2515 const field_ty: Type =
2516 .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
24732517 const field_default_class = switch (field_default) {
24742518 .none => .no_possible_value,
24752519 else => field_ty.classify(zcu),
24762520 };
2477 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (field_default_class) {
2478 .no_possible_value, .one_possible_value => if (is_comptime) .field_comptime else .field,
2479 .runtime => if (is_comptime) .field_comptime_fully_runtime else .field_default_fully_runtime,
2480 .partially_comptime => if (is_comptime) .field_comptime_partially_comptime else .field_default_partially_comptime,
2481 .fully_comptime => if (is_comptime) .field_comptime_fully_comptime else .field_default_fully_comptime,
2482 }));
2483 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
2521 try dwarf.abbrevCode(di_nw, if (is_comptime) switch (field_default_class) {
2522 .no_possible_value, .one_possible_value => .field_comptime,
2523 .runtime => .field_comptime_fully_runtime,
2524 .partially_comptime => .field_comptime_partially_comptime,
2525 .fully_comptime => .field_comptime_fully_comptime,
2526 } else switch (field_default_class) {
2527 .no_possible_value, .one_possible_value => .field,
2528 .runtime => .field_default_fully_runtime,
2529 .partially_comptime => .field_default_partially_comptime,
2530 .fully_comptime => .field_default_fully_comptime,
2531 });
2532 try dwarf.strp(
2533 &dwarf.debug_str,
2534 di_nw,
2535 loaded_struct.field_names.get(ip)[field_index].toSlice(ip),
2536 );
24842537 try dwarf.refType(pt, di_nw, field_ty);
24852538 if (!is_comptime) {
2486 try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
2487 try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
2488 field_ty.abiAlignment(zcu).toByteUnits().?);
2539 try di_w.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]);
2540 try di_w.writeUleb128(loaded_struct.field_aligns.getOrNone(
2541 ip,
2542 field_index,
2543 ).toByteUnits() orelse field_ty.abiAlignment(zcu).toByteUnits().?);
24892544 }
24902545 if (field_default_class.hasRuntimeBits())
24912546 try dwarf.blockConst(pt, di_nw, .fromInterned(field_default));
......@@ -2498,17 +2553,22 @@ fn updateConstInner(
24982553 try dwarf.genCaptures(pt, di_nw, loaded_struct.captures);
24992554 var field_bit_offset: u16 = 0;
25002555 for (0..loaded_struct.field_types.len) |field_index| {
2501 try diw.writeUleb128(try dwarf.refAbbrevCode(.packed_field));
2502 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
2503 const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
2556 try dwarf.abbrevCode(di_nw, .packed_field);
2557 try dwarf.strp(
2558 &dwarf.debug_str,
2559 di_nw,
2560 loaded_struct.field_names.get(ip)[field_index].toSlice(ip),
2561 );
2562 const field_ty: Type =
2563 .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
25042564 try dwarf.refType(pt, di_nw, field_ty);
2505 try diw.writeUleb128(field_bit_offset);
2565 try di_w.writeUleb128(field_bit_offset);
25062566 field_bit_offset += @intCast(field_ty.bitSize(zcu));
25072567 }
25082568 },
25092569 }
25102570 if (loaded_struct.captures.len > 0 or loaded_struct.field_types.len > 0)
2511 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2571 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
25122572 },
25132573 .union_type => {
25142574 const loaded_union = ip.loadUnionType(val);
......@@ -2516,15 +2576,14 @@ fn updateConstInner(
25162576 const zfi = loaded_union.zir_index.resolveFile(ip);
25172577 const zf = zcu.fileByIndex(zfi);
25182578 if (loaded_union.captures.len > 0 or loaded_union.is_reified) {
2519 try diw.writeUleb128(try dwarf.refAbbrevCode(
2520 if (loaded_union.captures.len > 0 or loaded_union.field_types.len > 0) switch (loaded_union.layout) {
2521 .auto, .@"extern" => .decl_instance_union,
2522 .@"packed" => .decl_instance_packed_union,
2523 } else switch (loaded_union.layout) {
2524 .auto, .@"extern" => .decl_instance_empty_union,
2525 .@"packed" => .decl_instance_empty_packed_union,
2526 },
2527 ));
2579 try dwarf.abbrevCode(di_nw, if (loaded_union.captures.len > 0 or
2580 loaded_union.field_types.len > 0) switch (loaded_union.layout) {
2581 .auto, .@"extern" => .decl_instance_union,
2582 .@"packed" => .decl_instance_packed_union,
2583 } else switch (loaded_union.layout) {
2584 .auto, .@"extern" => .decl_instance_empty_union,
2585 .@"packed" => .decl_instance_empty_packed_union,
2586 });
25282587 try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0);
25292588 } else if (loaded_union.name_nav.unwrap()) |name_ni| {
25302589 const name_nav = ip.getNav(name_ni);
......@@ -2532,86 +2591,118 @@ fn updateConstInner(
25322591 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
25332592 name_nav.analysis.?.namespace,
25342593 ).owner_type);
2535 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_union.layout) {
2536 .auto, .@"extern" => if (loaded_union.field_types.len > 0) .decl_union else .decl_empty_union,
2537 .@"packed" => if (loaded_union.field_types.len > 0) .decl_packed_union else .decl_empty_packed_union,
2538 }));
2594 try dwarf.abbrevCode(di_nw, if (loaded_union.field_types.len > 0)
2595 switch (loaded_union.layout) {
2596 .auto, .@"extern" => .decl_union,
2597 .@"packed" => .decl_packed_union,
2598 }
2599 else switch (loaded_union.layout) {
2600 .auto, .@"extern" => .decl_empty_union,
2601 .@"packed" => .decl_empty_packed_union,
2602 });
25392603 try dwarf.secOffset(di_nw, parent_ni, 0);
2540 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2541 try diw.writeUleb128(decl.src_column + 1);
2542 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
2604 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2605 try di_w.writeUleb128(decl.src_column + 1);
2606 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
25432607 try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip));
25442608 } else {
25452609 const decl = zf.zir.?.getUnionDecl(loaded_union.zir_index.resolve(ip).?);
25462610 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
25472611 ip.namespacePtr(loaded_union.namespace).parent.unwrap().?,
25482612 ).owner_type);
2549 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_union.layout) {
2550 .auto, .@"extern" => if (loaded_union.field_types.len > 0) .type_decl_union else .type_decl_empty_union,
2551 .@"packed" => if (loaded_union.field_types.len > 0) .type_decl_packed_union else .type_decl_empty_packed_union,
2552 }));
2613 try dwarf.abbrevCode(di_nw, if (loaded_union.field_types.len > 0)
2614 switch (loaded_union.layout) {
2615 .auto, .@"extern" => .type_decl_union,
2616 .@"packed" => .type_decl_packed_union,
2617 }
2618 else switch (loaded_union.layout) {
2619 .auto, .@"extern" => .type_decl_empty_union,
2620 .@"packed" => .type_decl_empty_packed_union,
2621 });
25532622 try dwarf.secOffset(di_nw, parent_ni, 0);
2554 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2555 try diw.writeUleb128(decl.src_column + 1);
2623 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2624 try di_w.writeUleb128(decl.src_column + 1);
25562625 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_union.name.toSlice(ip));
25572626 }
25582627 switch (loaded_union.layout) {
25592628 .auto, .@"extern" => {
25602629 const union_layout = Type.getUnionLayout(loaded_union, zcu);
2561 try diw.writeUleb128(union_layout.abi_size);
2562 try diw.writeUleb128(union_layout.abi_align.toByteUnits().?);
2630 try di_w.writeUleb128(union_layout.abi_size);
2631 try di_w.writeUleb128(union_layout.abi_align.toByteUnits().?);
25632632 try dwarf.genCaptures(pt, di_nw, loaded_union.captures);
25642633 if (loaded_union.has_runtime_tag) {
2565 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union));
2566 try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize());
2634 try dwarf.abbrevCode(di_nw, .tagged_union);
2635 try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize());
25672636 {
2568 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field));
2637 try dwarf.abbrevCode(di_nw, .generated_field);
25692638 try dwarf.strp(&dwarf.debug_str, di_nw, "tag");
25702639 try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.enum_tag_type));
2571 try diw.writeUleb128(union_layout.tagOffset());
2640 try di_w.writeUleb128(union_layout.tagOffset());
25722641
25732642 for (0..loaded_union.field_types.len) |field_index| {
2574 try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field));
2575 try dwarf.enumConstValue(diw, loaded_tag, field_index);
2643 try dwarf.abbrevCode(di_nw, .tagged_union_field);
2644 try dwarf.enumConstValue(di_w, loaded_tag, field_index);
25762645 {
2577 try diw.writeUleb128(try dwarf.refAbbrevCode(.field));
2646 try dwarf.abbrevCode(di_nw, .field);
25782647 try dwarf.strp(
25792648 &dwarf.debug_str,
25802649 di_nw,
25812650 loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
25822651 );
2583 const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
2652 const field_ty: Type =
2653 .fromInterned(loaded_union.field_types.get(ip)[field_index]);
25842654 try dwarf.refType(pt, di_nw, field_ty);
2585 try diw.writeUleb128(union_layout.payloadOffset());
2586 try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
2587 if (field_ty.isNoReturn(zcu)) 1 else field_ty.abiAlignment(zcu).toByteUnits().?);
2655 try di_w.writeUleb128(union_layout.payloadOffset());
2656 try di_w.writeUleb128(loaded_union.field_aligns.getOrNone(
2657 ip,
2658 field_index,
2659 ).toByteUnits() orelse if (field_ty.isNoReturn(zcu))
2660 1
2661 else
2662 field_ty.abiAlignment(zcu).toByteUnits().?);
25882663 }
2589 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2664 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
25902665 }
25912666 }
2592 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2667 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
25932668 } else for (0..loaded_union.field_types.len) |field_index| {
2594 try diw.writeUleb128(try dwarf.refAbbrevCode(.field));
2595 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
2596 const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
2669 try dwarf.abbrevCode(di_nw, .field);
2670 try dwarf.strp(
2671 &dwarf.debug_str,
2672 di_nw,
2673 loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
2674 );
2675 const field_ty: Type =
2676 .fromInterned(loaded_union.field_types.get(ip)[field_index]);
25972677 try dwarf.refType(pt, di_nw, field_ty);
2598 try diw.writeUleb128(0);
2599 try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse
2600 if (field_ty.isNoReturn(zcu)) 1 else field_ty.abiAlignment(zcu).toByteUnits().?);
2678 try di_w.writeUleb128(0);
2679 try di_w.writeUleb128(loaded_union.field_aligns.getOrNone(
2680 ip,
2681 field_index,
2682 ).toByteUnits() orelse if (field_ty.isNoReturn(zcu))
2683 1
2684 else
2685 field_ty.abiAlignment(zcu).toByteUnits().?);
26012686 }
26022687 },
26032688 .@"packed" => {
26042689 try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.packed_backing_int_type));
26052690 for (0..loaded_union.field_types.len) |field_index| {
2606 try diw.writeUleb128(try dwarf.refAbbrevCode(.packed_field));
2607 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_tag.field_names.get(ip)[field_index].toSlice(ip));
2608 try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.field_types.get(ip)[field_index]));
2609 try diw.writeUleb128(0);
2691 try dwarf.abbrevCode(di_nw, .packed_field);
2692 try dwarf.strp(
2693 &dwarf.debug_str,
2694 di_nw,
2695 loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
2696 );
2697 try dwarf.refType(pt, di_nw, .fromInterned(
2698 loaded_union.field_types.get(ip)[field_index],
2699 ));
2700 try di_w.writeUleb128(0);
26102701 }
26112702 },
26122703 }
26132704 if (loaded_union.captures.len > 0 or loaded_union.field_types.len > 0)
2614 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2705 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
26152706 },
26162707 .enum_type => {
26172708 const loaded_enum = ip.loadEnumType(val);
......@@ -2620,12 +2711,11 @@ fn updateConstInner(
26202711 const zfi = loaded_enum.zir_index.unwrap().?.resolveFile(ip);
26212712 const zf = zcu.fileByIndex(zfi);
26222713 if (loaded_enum.captures.len > 0 or loaded_enum.is_reified) {
2623 try diw.writeUleb128(try dwarf.refAbbrevCode(
2624 if (loaded_enum.captures.len > 0 or loaded_enum.field_names.len > 0)
2625 .decl_instance_enum
2626 else
2627 .decl_instance_empty_enum,
2628 ));
2714 try dwarf.abbrevCode(di_nw, if (loaded_enum.captures.len > 0 or
2715 loaded_enum.field_names.len > 0)
2716 .decl_instance_enum
2717 else
2718 .decl_instance_empty_enum);
26292719 try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0);
26302720 } else if (loaded_enum.name_nav.unwrap()) |name_ni| {
26312721 const name_nav = ip.getNav(name_ni);
......@@ -2633,43 +2723,51 @@ fn updateConstInner(
26332723 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
26342724 name_nav.analysis.?.namespace,
26352725 ).owner_type);
2636 try diw.writeUleb128(try dwarf.refAbbrevCode(
2726 try dwarf.abbrevCode(
2727 di_nw,
26372728 if (loaded_enum.field_names.len > 0) .decl_enum else .decl_empty_enum,
2638 ));
2729 );
26392730 try dwarf.secOffset(di_nw, parent_ni, 0);
2640 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2641 try diw.writeUleb128(decl.src_column + 1);
2642 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
2731 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2732 try di_w.writeUleb128(decl.src_column + 1);
2733 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
26432734 try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip));
26442735 } else {
2645 const decl = zf.zir.?.getEnumDecl(loaded_enum.zir_index.unwrap().?.resolve(ip).?);
2736 const decl =
2737 zf.zir.?.getEnumDecl(loaded_enum.zir_index.unwrap().?.resolve(ip).?);
26462738 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
26472739 ip.namespacePtr(loaded_enum.namespace).parent.unwrap().?,
26482740 ).owner_type);
2649 try diw.writeUleb128(try dwarf.refAbbrevCode(
2650 if (loaded_enum.field_names.len > 0) .type_decl_enum else .type_decl_empty_enum,
2651 ));
2741 try dwarf.abbrevCode(di_nw, if (loaded_enum.field_names.len > 0)
2742 .type_decl_enum
2743 else
2744 .type_decl_empty_enum);
26522745 try dwarf.secOffset(di_nw, parent_ni, 0);
2653 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2654 try diw.writeUleb128(decl.src_column + 1);
2746 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2747 try di_w.writeUleb128(decl.src_column + 1);
26552748 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.name.toSlice(ip));
26562749 }
26572750 },
26582751 else => {
2659 try diw.writeUleb128(try dwarf.refAbbrevCode(
2660 if (loaded_enum.field_names.len > 0) .generated_enum_type else .generated_empty_enum_type,
2661 ));
2752 try dwarf.abbrevCode(di_nw, if (loaded_enum.field_names.len > 0)
2753 .generated_enum_type
2754 else
2755 .generated_empty_enum_type);
26622756 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.fqn.toSlice(ip));
26632757 },
26642758 }
26652759 try dwarf.refType(pt, di_nw, .fromInterned(loaded_enum.int_tag_type));
26662760 for (0..loaded_enum.field_names.len) |field_index| {
2667 try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field));
2668 try dwarf.enumConstValue(diw, loaded_enum, field_index);
2669 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.field_names.get(ip)[field_index].toSlice(ip));
2761 try dwarf.abbrevCode(di_nw, .enum_field);
2762 try dwarf.enumConstValue(di_w, loaded_enum, field_index);
2763 try dwarf.strp(
2764 &dwarf.debug_str,
2765 di_nw,
2766 loaded_enum.field_names.get(ip)[field_index].toSlice(ip),
2767 );
26702768 }
26712769 if (loaded_enum.captures.len > 0 or loaded_enum.field_names.len > 0)
2672 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2770 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
26732771 },
26742772 // no defined size, so lowered the same as incomplete struct types
26752773 .opaque_type => return dwarf.updateConstIncompleteInner(pt, di_nw, val),
......@@ -2678,9 +2776,7 @@ fn updateConstInner(
26782776 const is_nullary = func_type.param_types.len == 0 and !func_type.is_var_args;
26792777 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
26802778 defer zcu.gpa.free(name);
2681 try diw.writeUleb128(try dwarf.refAbbrevCode(
2682 if (is_nullary) .nullary_func_type else .func_type,
2683 ));
2779 try dwarf.abbrevCode(di_nw, if (is_nullary) .nullary_func_type else .func_type);
26842780 try dwarf.strp(&dwarf.debug_str, di_nw, name);
26852781 const cc: DW.CC = cc: {
26862782 if (zcu.getTarget().cCallingConvention()) |cc| {
......@@ -2751,38 +2847,41 @@ fn updateConstInner(
27512847 else => .nocall,
27522848 };
27532849 };
2754 try diw.writeByte(@backingInt(cc));
2850 try di_w.writeByte(@backingInt(cc));
27552851 try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type));
27562852 if (!is_nullary) {
27572853 for (0..func_type.param_types.len) |param_index| {
2758 try diw.writeUleb128(try dwarf.refAbbrevCode(.unnamed_param));
2759 try dwarf.refType(pt, di_nw, .fromInterned(func_type.param_types.get(ip)[param_index]));
2854 try dwarf.abbrevCode(di_nw, .unnamed_param);
2855 try dwarf.refType(pt, di_nw, .fromInterned(
2856 func_type.param_types.get(ip)[param_index],
2857 ));
27602858 }
2761 if (func_type.is_var_args) try diw.writeUleb128(try dwarf.refAbbrevCode(.is_var_args));
2762 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2859 if (func_type.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args);
2860 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
27632861 }
27642862 },
27652863 .error_set_type => |error_set_type| {
27662864 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
27672865 defer zcu.gpa.free(name);
2768 try diw.writeUleb128(try dwarf.refAbbrevCode(
2866 try dwarf.abbrevCode(
2867 di_nw,
27692868 if (error_set_type.names.len > 0) .generated_enum_type else .generated_empty_enum_type,
2770 ));
2869 );
27712870 try dwarf.strp(&dwarf.debug_str, di_nw, name);
27722871 try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits()));
27732872 for (0..error_set_type.names.len) |field_index| {
27742873 const field_name = error_set_type.names.get(ip)[field_index];
2775 try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field));
2776 try diw.writeUleb128(DW.FORM.udata);
2777 try diw.writeUleb128(ip.getErrorValueIfExists(field_name).?);
2874 try dwarf.abbrevCode(di_nw, .enum_field);
2875 try di_w.writeUleb128(DW.FORM.udata);
2876 try di_w.writeUleb128(ip.getErrorValueIfExists(field_name).?);
27782877 try dwarf.strp(&dwarf.debug_str, di_nw, field_name.toSlice(ip));
27792878 }
2780 if (error_set_type.names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null));
2879 if (error_set_type.names.len > 0) try di_w.writeUleb128(@backingInt(AbbrevCode.null));
27812880 },
27822881 .inferred_error_set_type => |func| {
27832882 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
27842883 defer zcu.gpa.free(name);
2785 try diw.writeUleb128(try dwarf.refAbbrevCode(.inferred_error_set_type));
2884 try dwarf.abbrevCode(di_nw, .inferred_error_set_type);
27862885 try dwarf.strp(&dwarf.debug_str, di_nw, name);
27872886 try dwarf.refType(pt, di_nw, switch (ies: {
27882887 const fi = dwarf.getFuncIfExists(ip.indexToKey(func).func.owner_nav) orelse
......@@ -2810,32 +2909,36 @@ fn updateConstInner(
28102909 const zf = zcu.fileByIndex(inst_info.file);
28112910 const decl = zf.zir.?.getDeclaration(inst_info.inst);
28122911 const parent_ty: Type = .fromInterned(ip.namespacePtr(nav.analysis.?.namespace).owner_type);
2813 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_func_generic));
2912 try dwarf.abbrevCode(di_nw, .decl_func_generic);
28142913 try dwarf.refType(pt, di_nw, parent_ty);
2815 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
2816 try diw.writeUleb128(decl.src_column + 1);
2817 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
2914 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
2915 try di_w.writeUleb128(decl.src_column + 1);
2916 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
28182917 try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip));
28192918 try dwarf.refType(pt, di_nw, .fromInterned(fn_ty.return_type));
28202919 var param_index: u32 = 0;
28212920 for (zf.zir.?.getParamBody(func.zir_body_inst.resolve(ip).?)) |param_inst| {
28222921 switch (zf.zir.?.getParamName(param_inst) orelse break) {
2823 .empty => try diw.writeUleb128(try dwarf.refAbbrevCode(.unnamed_param)),
2922 .empty => try dwarf.abbrevCode(di_nw, .unnamed_param),
28242923 else => |param_name| {
2825 try diw.writeUleb128(try dwarf.refAbbrevCode(.param));
2826 try dwarf.strp(&dwarf.debug_str, di_nw, zf.zir.?.nullTerminatedString(param_name));
2924 try dwarf.abbrevCode(di_nw, .param);
2925 try dwarf.strp(&dwarf.debug_str, di_nw, zf.zir.?.nullTerminatedString(
2926 param_name,
2927 ));
28272928 },
28282929 }
2829 try dwarf.refType(pt, di_nw, .fromInterned(fn_ty.param_types.get(&zcu.intern_pool)[param_index]));
2930 try dwarf.refType(pt, di_nw, .fromInterned(
2931 fn_ty.param_types.get(&zcu.intern_pool)[param_index],
2932 ));
28302933 param_index += 1;
28312934 }
2832 if (fn_ty.is_var_args) try diw.writeUleb128(try dwarf.refAbbrevCode(.is_var_args));
2833 try diw.writeUleb128(@backingInt(AbbrevCode.null));
2935 if (fn_ty.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args);
2936 try di_w.writeUleb128(@backingInt(AbbrevCode.null));
28342937 },
28352938
28362939 .memoized_call => unreachable, // not a value
28372940 }
2838 try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen());
2941 try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen());
28392942}
28402943
28412944fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } {
......@@ -2870,13 +2973,13 @@ fn updateConstIncompleteInner(
28702973) link.EmitError!void {
28712974 const zcu = pt.zcu;
28722975 const ip = &zcu.intern_pool;
2873 const diw = &di_nw.interface;
2976 const di_w = &di_nw.interface;
28742977 done: {
28752978 const kind: enum { @"struct", @"union", @"enum" }, const zf, const src_line, const src_column, const is_reified, const captures, const name, const maybe_name_nav, const namespace = container: switch (ip.indexToKey(val)) {
28762979 .struct_type => {
28772980 const loaded_struct = ip.loadStructType(val);
28782981 const src_inst = loaded_struct.zir_index.resolveFull(ip) orelse {
2879 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
2982 try dwarf.lostTracking(di_nw);
28802983 break :done;
28812984 };
28822985 const zf = zcu.fileByIndex(src_inst.file);
......@@ -2884,14 +2987,15 @@ fn updateConstIncompleteInner(
28842987 .main_struct_inst => {
28852988 const ui = dwarf.getUnit(zf.mod.?);
28862989 _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, src_inst.file);
2887 try diw.writeUleb128(try dwarf.refAbbrevCode(.empty_file));
2888 try diw.writeUleb128(@backingInt(fi));
2990 try dwarf.abbrevCode(di_nw, .empty_file);
2991 try di_w.writeUleb128(@backingInt(fi));
28892992 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip));
2890 try diw.writeByte(@intFromBool(true));
2993 try di_w.writeByte(@intFromBool(true));
28912994 break :done;
28922995 },
28932996 else => {
2894 const data = zf.zir.?.instructions.items(.data)[@backingInt(src_inst.inst)].extended;
2997 const data =
2998 zf.zir.?.instructions.items(.data)[@backingInt(src_inst.inst)].extended;
28952999 const src_line, const src_column = src_loc: switch (data.opcode) {
28963000 else => unreachable,
28973001 .struct_decl => {
......@@ -2899,7 +3003,10 @@ fn updateConstIncompleteInner(
28993003 break :src_loc .{ decl.src_line, decl.src_column };
29003004 },
29013005 .reify_struct => {
2902 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.ReifyStruct, data.operand).data;
3006 const decl = zf.zir.?.extraData(
3007 std.zig.Zir.Inst.ReifyStruct,
3008 data.operand,
3009 ).data;
29033010 break :src_loc .{ decl.src_line, decl.src_column };
29043011 },
29053012 };
......@@ -2920,7 +3027,7 @@ fn updateConstIncompleteInner(
29203027 .union_type => {
29213028 const loaded_union = ip.loadUnionType(val);
29223029 const src_inst = loaded_union.zir_index.resolveFull(ip) orelse {
2923 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3030 try dwarf.lostTracking(di_nw);
29243031 break :done;
29253032 };
29263033 const zf = zcu.fileByIndex(src_inst.file);
......@@ -2951,13 +3058,13 @@ fn updateConstIncompleteInner(
29513058 .enum_type => {
29523059 const loaded_enum = ip.loadEnumType(val);
29533060 const zir_index = loaded_enum.zir_index.unwrap() orelse {
2954 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_empty_struct_type));
3061 try dwarf.abbrevCode(di_nw, .generated_empty_struct_type);
29553062 try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.name.toSlice(ip));
2956 try diw.writeByte(@intFromBool(true));
3063 try di_w.writeByte(@intFromBool(true));
29573064 break :done;
29583065 };
29593066 const src_inst = zir_index.resolveFull(ip) orelse {
2960 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3067 try dwarf.lostTracking(di_nw);
29613068 break :done;
29623069 };
29633070 const zf = zcu.fileByIndex(src_inst.file);
......@@ -2989,7 +3096,7 @@ fn updateConstIncompleteInner(
29893096 .opaque_type => {
29903097 const loaded_opaque = ip.loadOpaqueType(val);
29913098 const src_inst = loaded_opaque.zir_index.resolveFull(ip) orelse {
2992 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3099 try dwarf.lostTracking(di_nw);
29933100 break :done;
29943101 };
29953102 const zf = zcu.fileByIndex(src_inst.file);
......@@ -3010,18 +3117,18 @@ fn updateConstIncompleteInner(
30103117 .type_type => {
30113118 const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)});
30123119 defer zcu.gpa.free(name);
3013 try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_empty_struct_type));
3120 try dwarf.abbrevCode(di_nw, .generated_empty_struct_type);
30143121 try dwarf.strp(&dwarf.debug_str, di_nw, name);
3015 try diw.writeByte(@intFromBool(true));
3122 try di_w.writeByte(@intFromBool(true));
30163123 },
30173124 else => |ty| {
3018 try diw.writeUleb128(try dwarf.refAbbrevCode(.undefined_comptime_value));
3125 try dwarf.abbrevCode(di_nw, .undefined_comptime_value);
30193126 try dwarf.refType(pt, di_nw, .fromInterned(ty));
30203127 },
30213128 },
30223129 };
30233130 if (captures.len > 0 or is_reified) {
3024 try diw.writeUleb128(try dwarf.refAbbrevCode(if (captures.len > 0) switch (kind) {
3131 try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) {
30253132 .@"struct" => .decl_instance_incomplete_struct,
30263133 .@"union" => .decl_instance_incomplete_union,
30273134 .@"enum" => .decl_instance_incomplete_enum,
......@@ -3029,7 +3136,7 @@ fn updateConstIncompleteInner(
30293136 .@"struct" => .decl_instance_empty_incomplete_struct,
30303137 .@"union" => .decl_instance_empty_incomplete_union,
30313138 .@"enum" => .decl_instance_empty_incomplete_enum,
3032 }));
3139 });
30333140 try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0);
30343141 } else if (maybe_name_nav.unwrap()) |name_ni| {
30353142 const name_nav = ip.getNav(name_ni);
......@@ -3037,7 +3144,7 @@ fn updateConstIncompleteInner(
30373144 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
30383145 name_nav.analysis.?.namespace,
30393146 ).owner_type);
3040 try diw.writeUleb128(try dwarf.refAbbrevCode(if (captures.len > 0) switch (kind) {
3147 try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) {
30413148 .@"struct" => .decl_incomplete_struct,
30423149 .@"union" => .decl_incomplete_union,
30433150 .@"enum" => .decl_incomplete_enum,
......@@ -3045,17 +3152,17 @@ fn updateConstIncompleteInner(
30453152 .@"struct" => .decl_empty_incomplete_struct,
30463153 .@"union" => .decl_empty_incomplete_union,
30473154 .@"enum" => .decl_empty_incomplete_enum,
3048 }));
3155 });
30493156 try dwarf.secOffset(di_nw, parent_ni, 0);
3050 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
3051 try diw.writeUleb128(decl.src_column + 1);
3052 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
3157 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
3158 try di_w.writeUleb128(decl.src_column + 1);
3159 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
30533160 try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip));
30543161 } else {
30553162 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
30563163 ip.namespacePtr(namespace).parent.unwrap().?,
30573164 ).owner_type);
3058 try diw.writeUleb128(try dwarf.refAbbrevCode(if (captures.len > 0) switch (kind) {
3165 try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) {
30593166 .@"struct" => .type_decl_incomplete_struct,
30603167 .@"union" => .type_decl_incomplete_union,
30613168 .@"enum" => .type_decl_incomplete_enum,
......@@ -3063,16 +3170,16 @@ fn updateConstIncompleteInner(
30633170 .@"struct" => .type_decl_empty_incomplete_struct,
30643171 .@"union" => .type_decl_empty_incomplete_union,
30653172 .@"enum" => .type_decl_empty_incomplete_enum,
3066 }));
3173 });
30673174 try dwarf.secOffset(di_nw, parent_ni, 0);
3068 try diw.writeInt(u32, src_line + 1, dwarf.endian);
3069 try diw.writeUleb128(src_column + 1);
3175 try di_w.writeInt(u32, src_line + 1, dwarf.endian);
3176 try di_w.writeUleb128(src_column + 1);
30703177 try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip));
30713178 }
30723179 try dwarf.genCaptures(pt, di_nw, captures);
3073 if (captures.len > 0) try diw.writeByte(@backingInt(AbbrevCode.null));
3180 if (captures.len > 0) try di_w.writeByte(@backingInt(AbbrevCode.null));
30743181 }
3075 try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen());
3182 try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen());
30763183}
30773184
30783185fn genCaptures(
......@@ -3083,36 +3190,35 @@ fn genCaptures(
30833190) link.EmitError!void {
30843191 const zcu = pt.zcu;
30853192 const ip = &zcu.intern_pool;
3086 const diw = &di_nw.interface;
30873193 for (captures.get(ip)) |capture| switch (capture.unwrap()) {
30883194 .@"comptime" => |capture_val| {
30893195 const ty: Type = .fromInterned(ip.typeOf(capture_val));
30903196 const ty_class = ty.classify(zcu);
3091 try diw.writeUleb128(try dwarf.refAbbrevCode(switch (ty_class) {
3197 try dwarf.abbrevCode(di_nw, switch (ty_class) {
30923198 .no_possible_value => unreachable,
30933199 .one_possible_value => .comptime_capture,
30943200 .runtime => .comptime_capture_runtime,
30953201 .partially_comptime => .comptime_capture_partially_comptime,
30963202 .fully_comptime => .comptime_capture_fully_comptime,
3097 }));
3203 });
30983204 try dwarf.refType(pt, di_nw, ty);
30993205 if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, .fromInterned(capture_val));
31003206 if (ty_class.comptimeOnly()) try dwarf.refConst(pt, di_nw, .fromInterned(capture_val));
31013207 },
31023208 .runtime => |capture_ty| {
3103 try diw.writeUleb128(try dwarf.refAbbrevCode(.runtime_capture));
3209 try dwarf.abbrevCode(di_nw, .runtime_capture);
31043210 try dwarf.refType(pt, di_nw, .fromInterned(capture_ty));
31053211 },
31063212 .nav_val => |capture_nav| {
31073213 const gi = try dwarf.getGlobal(capture_nav);
3108 try diw.writeUleb128(try dwarf.refAbbrevCode(.nav_capture));
3214 try dwarf.abbrevCode(di_nw, .nav_capture);
31093215 try dwarf.exprLoc(di_nw, .{ .implicit_pointer = .{
31103216 .node = gi.get(dwarf).debug_info_ni.unwrap().?,
31113217 } });
31123218 },
31133219 .nav_ref => |capture_nav| {
31143220 const gi = try dwarf.getGlobal(capture_nav);
3115 try diw.writeUleb128(try dwarf.refAbbrevCode(.nav_capture));
3221 try dwarf.abbrevCode(di_nw, .nav_capture);
31163222 try dwarf.exprLoc(di_nw, .{ .stack_value = &.{ .implicit_pointer = .{
31173223 .node = gi.get(dwarf).debug_info_ni.unwrap().?,
31183224 } } });
......@@ -3140,14 +3246,14 @@ fn genDeclInner(
31403246) link.EmitError!void {
31413247 const zcu = pt.zcu;
31423248 const ip = &zcu.intern_pool;
3143 const diw = &di_nw.interface;
3249 const di_w = &di_nw.interface;
31443250 done: {
31453251 const kind: enum { @"struct", @"union", @"enum" }, const zf, const src_line, const src_column, const capture_names, const captures, const name, const maybe_name_nav, const namespace = container: switch (ip.indexToKey(instance_val)) {
31463252 else => unreachable,
31473253 .struct_type => {
31483254 const loaded_struct = ip.loadStructType(instance_val);
31493255 const src_inst = loaded_struct.zir_index.resolveFull(ip) orelse {
3150 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3256 try dwarf.lostTracking(di_nw);
31513257 break :done;
31523258 };
31533259 const zf = zcu.fileByIndex(src_inst.file);
......@@ -3155,11 +3261,17 @@ fn genDeclInner(
31553261 const src_line, const src_column, const capture_names = decl: switch (inst.tag) {
31563262 else => unreachable,
31573263 .struct_init, .struct_init_ref => {
3158 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.StructInit, inst.data.pl_node.payload_index).data;
3264 const decl = zf.zir.?.extraData(
3265 std.zig.Zir.Inst.StructInit,
3266 inst.data.pl_node.payload_index,
3267 ).data;
31593268 break :decl .{ decl.src_line, decl.src_column, &.{} };
31603269 },
31613270 .struct_init_anon => {
3162 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.StructInitAnon, inst.data.pl_node.payload_index).data;
3271 const decl = zf.zir.?.extraData(
3272 std.zig.Zir.Inst.StructInitAnon,
3273 inst.data.pl_node.payload_index,
3274 ).data;
31633275 break :decl .{ decl.src_line, decl.src_column, &.{} };
31643276 },
31653277 .extended => switch (inst.data.extended.opcode) {
......@@ -3169,7 +3281,10 @@ fn genDeclInner(
31693281 break :decl .{ decl.src_line, decl.src_column, decl.capture_names };
31703282 },
31713283 .reify_struct => {
3172 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.ReifyStruct, inst.data.extended.operand).data;
3284 const decl = zf.zir.?.extraData(
3285 std.zig.Zir.Inst.ReifyStruct,
3286 inst.data.extended.operand,
3287 ).data;
31733288 break :decl .{ decl.src_line, decl.src_column, &.{} };
31743289 },
31753290 },
......@@ -3189,7 +3304,7 @@ fn genDeclInner(
31893304 .union_type => {
31903305 const loaded_union = ip.loadUnionType(instance_val);
31913306 const src_inst = loaded_union.zir_index.resolveFull(ip) orelse {
3192 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3307 try dwarf.lostTracking(di_nw);
31933308 break :done;
31943309 };
31953310 const zf = zcu.fileByIndex(src_inst.file);
......@@ -3203,7 +3318,10 @@ fn genDeclInner(
32033318 break :decl .{ decl.src_line, decl.src_column, decl.capture_names };
32043319 },
32053320 .reify_union => {
3206 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.ReifyUnion, inst.data.extended.operand).data;
3321 const decl = zf.zir.?.extraData(
3322 std.zig.Zir.Inst.ReifyUnion,
3323 inst.data.extended.operand,
3324 ).data;
32073325 break :decl .{ decl.src_line, decl.src_column, &.{} };
32083326 },
32093327 },
......@@ -3223,7 +3341,7 @@ fn genDeclInner(
32233341 .enum_type => {
32243342 const loaded_enum = ip.loadEnumType(instance_val);
32253343 const src_inst = loaded_enum.zir_index.unwrap().?.resolveFull(ip) orelse {
3226 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3344 try dwarf.lostTracking(di_nw);
32273345 break :done;
32283346 };
32293347 const zf = zcu.fileByIndex(src_inst.file);
......@@ -3237,7 +3355,10 @@ fn genDeclInner(
32373355 break :decl .{ decl.src_line, decl.src_column, decl.capture_names };
32383356 },
32393357 .reify_enum => {
3240 const decl = zf.zir.?.extraData(std.zig.Zir.Inst.ReifyEnum, inst.data.extended.operand).data;
3358 const decl = zf.zir.?.extraData(
3359 std.zig.Zir.Inst.ReifyEnum,
3360 inst.data.extended.operand,
3361 ).data;
32413362 break :decl .{ decl.src_line, decl.src_column, &.{} };
32423363 },
32433364 },
......@@ -3257,7 +3378,7 @@ fn genDeclInner(
32573378 .opaque_type => {
32583379 const loaded_opaque = ip.loadOpaqueType(instance_val);
32593380 const src_inst = loaded_opaque.zir_index.resolveFull(ip) orelse {
3260 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3381 try dwarf.lostTracking(di_nw);
32613382 break :done;
32623383 };
32633384 const zf = zcu.fileByIndex(src_inst.file);
......@@ -3281,7 +3402,7 @@ fn genDeclInner(
32813402 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
32823403 name_nav.analysis.?.namespace,
32833404 ).owner_type);
3284 try diw.writeUleb128(try dwarf.refAbbrevCode(if (captures.len > 0) switch (kind) {
3405 try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) {
32853406 .@"struct" => .decl_specification_struct,
32863407 .@"union" => .decl_specification_union,
32873408 .@"enum" => .decl_specification_enum,
......@@ -3289,17 +3410,17 @@ fn genDeclInner(
32893410 .@"struct" => .decl_specification_empty_struct,
32903411 .@"union" => .decl_specification_empty_union,
32913412 .@"enum" => .decl_specification_empty_enum,
3292 }));
3413 });
32933414 try dwarf.secOffset(di_nw, parent_ni, 0);
3294 try diw.writeInt(u32, decl.src_line + 1, dwarf.endian);
3295 try diw.writeUleb128(decl.src_column + 1);
3296 try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
3415 try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian);
3416 try di_w.writeUleb128(decl.src_column + 1);
3417 try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private);
32973418 try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip));
32983419 } else {
32993420 const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr(
33003421 ip.namespacePtr(namespace).parent.unwrap().?,
33013422 ).owner_type);
3302 try diw.writeUleb128(try dwarf.refAbbrevCode(if (captures.len > 0) switch (kind) {
3423 try dwarf.abbrevCode(di_nw, if (captures.len > 0) switch (kind) {
33033424 .@"struct" => .type_decl_specification_struct,
33043425 .@"union" => .type_decl_specification_union,
33053426 .@"enum" => .type_decl_specification_enum,
......@@ -3307,14 +3428,14 @@ fn genDeclInner(
33073428 .@"struct" => .type_decl_specification_empty_struct,
33083429 .@"union" => .type_decl_specification_empty_union,
33093430 .@"enum" => .type_decl_specification_empty_enum,
3310 }));
3431 });
33113432 try dwarf.secOffset(di_nw, parent_ni, 0);
3312 try diw.writeInt(u32, src_line + 1, dwarf.endian);
3313 try diw.writeUleb128(src_column + 1);
3433 try di_w.writeInt(u32, src_line + 1, dwarf.endian);
3434 try di_w.writeUleb128(src_column + 1);
33143435 try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip));
33153436 }
33163437 for (capture_names, captures.get(ip)) |capture_name, capture| {
3317 try diw.writeUleb128(try dwarf.refAbbrevCode(.capture_specification));
3438 try dwarf.abbrevCode(di_nw, .capture_specification);
33183439 switch (capture.unwrap()) {
33193440 .@"comptime", .runtime, .nav_val => try dwarf.strp(
33203441 &dwarf.debug_str,
......@@ -3330,9 +3451,9 @@ fn genDeclInner(
33303451 },
33313452 }
33323453 }
3333 if (captures.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null));
3454 if (captures.len > 0) try di_w.writeUleb128(@backingInt(AbbrevCode.null));
33343455 }
3335 try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen());
3456 try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen());
33363457}
33373458
33383459pub fn updateLineNumber(
......@@ -3351,8 +3472,8 @@ pub fn updateLineNumber(
33513472 );
33523473}
33533474
3354pub fn lostTracking(dwarf: *Dwarf, diw: *std.Io.Writer) link.EmitError!void {
3355 try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost));
3475pub fn lostTracking(dwarf: *Dwarf, di_nw: *MappedFile.Node.Writer) link.EmitError!void {
3476 try dwarf.abbrevCode(di_nw, .decl_lost);
33563477}
33573478
33583479fn refAbbrevCodeIfExists(
......@@ -3362,9 +3483,9 @@ fn refAbbrevCodeIfExists(
33623483 assert(abbrev_code != .null);
33633484 return if (dwarf.debug_abbrev.set.contains(abbrev_code)) @backingInt(abbrev_code) else null;
33643485}
3365
33663486fn refAbbrevCode(
33673487 dwarf: *Dwarf,
3488 mf: *MappedFile,
33683489 abbrev_code: AbbrevCode,
33693490) link.Error!@typeInfo(AbbrevCode).@"enum".tag_type {
33703491 if (dwarf.refAbbrevCodeIfExists(abbrev_code)) |backing_int| {
......@@ -3372,7 +3493,7 @@ fn refAbbrevCode(
33723493 return backing_int;
33733494 }
33743495 var da_nw: MappedFile.Node.Writer = undefined;
3375 dwarf.debug_abbrev.ni.unwrap().?.writer(dwarf.lf.comp.gpa, &dwarf.lf.cast(.elf2).?.mf, &da_nw);
3496 dwarf.debug_abbrev.ni.unwrap().?.writer(dwarf.lf.comp.gpa, mf, &da_nw);
33763497 defer da_nw.deinit();
33773498 dwarf.genDebugAbbrev(&da_nw, abbrev_code) catch |err| switch (err) {
33783499 else => |e| return e,
......@@ -3381,6 +3502,13 @@ fn refAbbrevCode(
33813502 dwarf.debug_abbrev.set.insert(abbrev_code);
33823503 return dwarf.refAbbrevCodeIfExists(abbrev_code).?;
33833504}
3505fn abbrevCode(
3506 dwarf: *Dwarf,
3507 nw: *MappedFile.Node.Writer,
3508 abbrev_code: AbbrevCode,
3509) link.EmitError!void {
3510 try nw.interface.writeUleb128(try dwarf.refAbbrevCode(nw.mf, abbrev_code));
3511}
33843512
33853513fn genDebugAbbrev(
33863514 dwarf: *Dwarf,
......@@ -3388,20 +3516,20 @@ fn genDebugAbbrev(
33883516 abbrev_code: AbbrevCode,
33893517) link.EmitError!void {
33903518 const abbrev = AbbrevCode.abbrevs.get(abbrev_code);
3391 const daw = &da_nw.interface;
3392 daw.end = dwarf.debug_abbrev.end;
3393 try daw.writeUleb128(@backingInt(abbrev_code));
3394 try daw.writeUleb128(@backingInt(abbrev.tag));
3395 try daw.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no);
3519 const da_w = &da_nw.interface;
3520 da_w.end = dwarf.debug_abbrev.end;
3521 try da_w.writeUleb128(@backingInt(abbrev_code));
3522 try da_w.writeUleb128(@backingInt(abbrev.tag));
3523 try da_w.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no);
33963524 for (abbrev.attrs) |*attr| {
3397 try daw.writeUleb128(@backingInt(switch (attr[0]) {
3525 try da_w.writeUleb128(@backingInt(switch (attr[0]) {
33983526 else => |at| at,
33993527 .ZIG_call_line_relative => |at| if (dwarf.lf.comp.config.incremental) at else .call_line,
34003528 }));
3401 try daw.writeUleb128(@backingInt(attr[1]));
3529 try da_w.writeUleb128(@backingInt(attr[1]));
34023530 }
3403 for (0..2) |_| try daw.writeUleb128(0);
3404 dwarf.debug_abbrev.end = daw.end;
3531 for (0..2) |_| try da_w.writeUleb128(0);
3532 dwarf.debug_abbrev.end = da_w.end;
34053533}
34063534
34073535pub fn secOffsetSize(dwarf: *Dwarf) usize {
......@@ -3421,11 +3549,16 @@ fn secOffset(
34213549) link.EmitError!void {
34223550 const offset = nw.interface.end;
34233551 try dwarf.secOffsetPlaceholder(&nw.interface);
3424 const elf = dwarf.lf.cast(.elf2).?;
3425 try elf.addNodeReloc(nw.ni, offset, target_ni, @bitCast(@as(u64, addend)), switch (dwarf.format) {
3426 .@"32" => .abs32,
3427 .@"64" => .abs64,
3428 });
3552 if (dwarf.lf.cast(.elf2)) |elf| try elf.addNodeReloc(
3553 nw.ni,
3554 offset,
3555 target_ni,
3556 @bitCast(@as(u64, addend)),
3557 switch (dwarf.format) {
3558 .@"32" => .abs32,
3559 .@"64" => .abs64,
3560 },
3561 ) else unreachable;
34293562}
34303563
34313564fn addrPlaceholder(dwarf: *Dwarf, w: *std.Io.Writer) std.Io.Writer.Error!void {
......@@ -3439,8 +3572,13 @@ fn addrSym(
34393572) link.EmitError!void {
34403573 const offset = nw.interface.end;
34413574 try dwarf.addrPlaceholder(&nw.interface);
3442 const elf = dwarf.lf.cast(.elf2).?;
3443 try elf.addReloc(@bitCast(nw.ni), offset, target_si, @bitCast(@as(u64, addend)), .absAddr(elf));
3575 if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc(
3576 @bitCast(nw.ni),
3577 offset,
3578 target_si,
3579 @bitCast(@as(u64, addend)),
3580 .absAddr(elf),
3581 ) else unreachable;
34443582}
34453583
34463584fn blockConst(
......@@ -3482,7 +3620,7 @@ fn refConst(
34823620
34833621fn bigIntConstValue(
34843622 dwarf: *Dwarf,
3485 diw: *std.Io.Writer,
3623 di_w: *std.Io.Writer,
34863624 ty: Type,
34873625 big_int: std.math.big.int.Const,
34883626) link.EmitError!void {
......@@ -3493,18 +3631,20 @@ fn bigIntConstValue(
34933631 };
34943632 const bits = @max(1, big_int.bitCountTwosCompForSignedness(signedness));
34953633 if (bits <= 64) {
3496 try diw.writeUleb128(@as(u13, switch (signedness) {
3634 try di_w.writeUleb128(@as(u13, switch (signedness) {
34973635 .signed => DW.FORM.sdata,
34983636 .unsigned => DW.FORM.udata,
34993637 }));
35003638 var bit: usize = 0;
35013639 var carry: u1 = 1;
3502 for (try diw.writableSlice(@divCeil(bits, 7))) |*byte| {
3640 for (try di_w.writableSlice(@divCeil(bits, 7))) |*byte| {
35033641 const limb_bits = @typeInfo(std.math.big.Limb).int.bits;
35043642 const limb_index = bit / limb_bits;
35053643 const limb_shift: std.math.Log2Int(std.math.big.Limb) = @intCast(bit % limb_bits);
35063644 const low_abs_part: u7 = @truncate(big_int.limbs[limb_index] >> limb_shift);
3507 const abs_part = if (limb_shift > limb_bits - 7 and limb_index + 1 < big_int.limbs.len) abs_part: {
3645 const abs_part = if (limb_shift > limb_bits - 7 and
3646 limb_index + 1 < big_int.limbs.len)
3647 abs_part: {
35083648 const high_abs_part: u7 = @truncate(big_int.limbs[limb_index + 1] << -%limb_shift);
35093649 break :abs_part high_abs_part | low_abs_part;
35103650 } else low_abs_part;
......@@ -3516,28 +3656,33 @@ fn bigIntConstValue(
35163656 byte.* = @as(u8, if (bit < bits) 0x80 else 0x00) | twos_comp_part;
35173657 }
35183658 } else {
3519 try diw.writeUleb128(DW.FORM.block);
3659 try di_w.writeUleb128(DW.FORM.block);
35203660 const size = switch (ty.toIntern()) {
35213661 .comptime_int_type => @divCeil(bits, 8),
35223662 else => ty.abiSize(zcu),
35233663 };
3524 try diw.writeUleb128(size);
3525 big_int.writeTwosComplement(try diw.writableSlice(@intCast(size)), dwarf.endian);
3664 try di_w.writeUleb128(size);
3665 big_int.writeTwosComplement(try di_w.writableSlice(@intCast(size)), dwarf.endian);
35263666 }
35273667}
35283668
35293669fn enumConstValue(
35303670 dwarf: *Dwarf,
3531 diw: *std.Io.Writer,
3671 di_w: *std.Io.Writer,
35323672 loaded_enum: InternPool.LoadedEnumType,
35333673 field_index: usize,
35343674) link.EmitError!void {
35353675 const zcu = dwarf.lf.comp.zcu.?;
35363676 var big_int_space: Value.BigIntSpace = undefined;
3537 try dwarf.bigIntConstValue(diw, .fromInterned(loaded_enum.int_tag_type), if (loaded_enum.field_values.len > 0)
3538 Value.fromInterned(loaded_enum.field_values.get(&zcu.intern_pool)[field_index]).toBigInt(&big_int_space, zcu)
3539 else
3540 std.math.big.int.Mutable.init(&big_int_space.limbs, field_index).toConst());
3677 try dwarf.bigIntConstValue(
3678 di_w,
3679 .fromInterned(loaded_enum.int_tag_type),
3680 if (loaded_enum.field_values.len > 0)
3681 Value.fromInterned(loaded_enum.field_values.get(&zcu.intern_pool)[field_index])
3682 .toBigInt(&big_int_space, zcu)
3683 else
3684 std.math.big.int.Mutable.init(&big_int_space.limbs, field_index).toConst(),
3685 );
35413686}
35423687
35433688fn exprLoc(dwarf: *Dwarf, nw: *MappedFile.Node.Writer, loc: Loc) link.EmitError!void {
......@@ -3577,7 +3722,8 @@ fn DeclValEnum(comptime T: type) type {
35773722 var min_value: ?comptime_int = null;
35783723 var max_value: ?comptime_int = null;
35793724 for (decl_names) |decl_name| {
3580 if (std.mem.startsWith(u8, decl_name, "HP_") or std.mem.endsWith(u8, decl_name, "_user")) continue;
3725 if (std.mem.startsWith(u8, decl_name, "HP_") or
3726 std.mem.endsWith(u8, decl_name, "_user")) continue;
35813727 const value = @field(T, decl_name);
35823728 field_names[fields_len] = decl_name;
35833729 fields_len += 1;
src/link/Elf2.zig+5-3
......@@ -9053,13 +9053,15 @@ pub fn lostTracking(
90539053 const di = elf.dwarf.getDeclIfExists(inst) orelse return;
90549054 const decl_ni = di.get(&elf.dwarf).debug_info_ni.unwrap() orelse return;
90559055 const comp = elf.base.comp;
9056 var diw: std.Io.Writer = .fixed(decl_ni.slice(&elf.mf));
9056 var di_nw: MappedFile.Node.Writer = undefined;
9057 decl_ni.writer(comp.gpa, &elf.mf, &di_nw);
9058 defer di_nw.deinit();
90579059 elf.resetNodeRelocs(decl_ni);
9058 elf.dwarf.lostTracking(&diw) catch |err| switch (err) {
9060 elf.dwarf.lostTracking(&di_nw) catch |err| switch (err) {
90599061 else => |e| return e,
90609062 error.WriteFailed => unreachable,
90619063 };
9062 decl_ni.resizeLeaf(comp.gpa, &elf.mf, diw.end) catch |err| switch (err) {
9064 decl_ni.resizeLeaf(comp.gpa, &elf.mf, di_nw.interface.end) catch |err| switch (err) {
90639065 else => |e| return e,
90649066 error.MappedFileIo => return comp.link_diags.fail("failed to write output file: {t}", .{
90659067 elf.mf.io_err.?,