| ... | @@ -491,22 +491,23 @@ pub const Cfa = union(enum) { | ... | @@ -491,22 +491,23 @@ pub const Cfa = union(enum) { |
| 491 | const RegExpr = struct { reg: u32, expr: Loc }; | 491 | const RegExpr = struct { reg: u32, expr: Loc }; |
| 492 | | 492 | |
| 493 | fn write(cfa: Cfa, wip_nav: *WipNav) link.EmitError!void { | 493 | 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; |
| 495 | switch (cfa) { | 496 | switch (cfa) { |
| 496 | .nop => try dfw.writeByte(DW.CFA.nop), | 497 | .nop => try df_w.writeByte(DW.CFA.nop), |
| 497 | .advance_loc => |loc| { | 498 | .advance_loc => |loc| { |
| 498 | const delta = | 499 | const delta = |
| 499 | @divExact(loc - wip_nav.cfi.loc, wip_nav.dwarf.frame.header.code_alignment_factor); | 500 | @divExact(loc - wip_nav.cfi.loc, wip_nav.dwarf.frame.header.code_alignment_factor); |
| 500 | if (delta == 0) {} else if (std.math.cast(u6, delta)) |small_delta| | 501 | 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) |
| 502 | else if (std.math.cast(u8, delta)) |ubyte_delta| | 503 | 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 }) |
| 504 | else if (std.math.cast(u16, delta)) |uhalf_delta| { | 505 | else if (std.math.cast(u16, delta)) |uhalf_delta| { |
| 505 | try dfw.writeByte(DW.CFA.advance_loc2); | 506 | try df_w.writeByte(DW.CFA.advance_loc2); |
| 506 | try dfw.writeInt(u16, uhalf_delta, wip_nav.dwarf.endian); | 507 | try df_w.writeInt(u16, uhalf_delta, wip_nav.dwarf.endian); |
| 507 | } else if (std.math.cast(u32, delta)) |uword_delta| { | 508 | } else if (std.math.cast(u32, delta)) |uword_delta| { |
| 508 | try dfw.writeByte(DW.CFA.advance_loc4); | 509 | try df_w.writeByte(DW.CFA.advance_loc4); |
| 509 | try dfw.writeInt(u32, uword_delta, wip_nav.dwarf.endian); | 510 | try df_w.writeInt(u32, uword_delta, wip_nav.dwarf.endian); |
| 510 | } | 511 | } |
| 511 | wip_nav.cfi.loc = loc; | 512 | wip_nav.cfi.loc = loc; |
| 512 | }, | 513 | }, |
| ... | @@ -518,41 +519,41 @@ pub const Cfa = union(enum) { | ... | @@ -518,41 +519,41 @@ pub const Cfa = union(enum) { |
| 518 | }, wip_nav.dwarf.frame.header.data_alignment_factor); | 519 | }, wip_nav.dwarf.frame.header.data_alignment_factor); |
| 519 | if (std.math.cast(u63, factored_off)) |unsigned_off| { | 520 | if (std.math.cast(u63, factored_off)) |unsigned_off| { |
| 520 | if (std.math.cast(u6, reg_off.reg)) |small_reg| { | 521 | 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); |
| 522 | } else { | 523 | } else { |
| 523 | try dfw.writeByte(DW.CFA.offset_extended); | 524 | try df_w.writeByte(DW.CFA.offset_extended); |
| 524 | try dfw.writeUleb128(reg_off.reg); | 525 | try df_w.writeUleb128(reg_off.reg); |
| 525 | } | 526 | } |
| 526 | try dfw.writeUleb128(unsigned_off); | 527 | try df_w.writeUleb128(unsigned_off); |
| 527 | } else { | 528 | } else { |
| 528 | try dfw.writeByte(DW.CFA.offset_extended_sf); | 529 | try df_w.writeByte(DW.CFA.offset_extended_sf); |
| 529 | try dfw.writeUleb128(reg_off.reg); | 530 | try df_w.writeUleb128(reg_off.reg); |
| 530 | try dfw.writeSleb128(factored_off); | 531 | try df_w.writeSleb128(factored_off); |
| 531 | } | 532 | } |
| 532 | }, | 533 | }, |
| 533 | .restore => |reg| if (std.math.cast(u6, reg)) |small_reg| | 534 | .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) |
| 535 | else { | 536 | else { |
| 536 | try dfw.writeByte(DW.CFA.restore_extended); | 537 | try df_w.writeByte(DW.CFA.restore_extended); |
| 537 | try dfw.writeUleb128(reg); | 538 | try df_w.writeUleb128(reg); |
| 538 | }, | 539 | }, |
| 539 | .undefined => |reg| { | 540 | .undefined => |reg| { |
| 540 | try dfw.writeByte(DW.CFA.undefined); | 541 | try df_w.writeByte(DW.CFA.undefined); |
| 541 | try dfw.writeUleb128(reg); | 542 | try df_w.writeUleb128(reg); |
| 542 | }, | 543 | }, |
| 543 | .same_value => |reg| { | 544 | .same_value => |reg| { |
| 544 | try dfw.writeByte(DW.CFA.same_value); | 545 | try df_w.writeByte(DW.CFA.same_value); |
| 545 | try dfw.writeUleb128(reg); | 546 | try df_w.writeUleb128(reg); |
| 546 | }, | 547 | }, |
| 547 | .register => |regs| if (regs[0] != regs[1]) { | 548 | .register => |regs| if (regs[0] != regs[1]) { |
| 548 | try dfw.writeByte(DW.CFA.register); | 549 | try df_w.writeByte(DW.CFA.register); |
| 549 | for (regs) |reg| try dfw.writeUleb128(reg); | 550 | for (regs) |reg| try df_w.writeUleb128(reg); |
| 550 | } else { | 551 | } else { |
| 551 | try dfw.writeByte(DW.CFA.same_value); | 552 | try df_w.writeByte(DW.CFA.same_value); |
| 552 | try dfw.writeUleb128(regs[0]); | 553 | try df_w.writeUleb128(regs[0]); |
| 553 | }, | 554 | }, |
| 554 | .remember_state => try dfw.writeByte(DW.CFA.remember_state), | 555 | .remember_state => try df_w.writeByte(DW.CFA.remember_state), |
| 555 | .restore_state => try dfw.writeByte(DW.CFA.restore_state), | 556 | .restore_state => try df_w.writeByte(DW.CFA.restore_state), |
| 556 | .def_cfa, .def_cfa_register, .def_cfa_offset, .adjust_cfa_offset => { | 557 | .def_cfa, .def_cfa_register, .def_cfa_offset, .adjust_cfa_offset => { |
| 557 | const reg_off: RegOff = switch (cfa) { | 558 | const reg_off: RegOff = switch (cfa) { |
| 558 | else => unreachable, | 559 | else => unreachable, |
| ... | @@ -568,54 +569,54 @@ pub const Cfa = union(enum) { | ... | @@ -568,54 +569,54 @@ pub const Cfa = union(enum) { |
| 568 | const unsigned_off = std.math.cast(u63, reg_off.off); | 569 | const unsigned_off = std.math.cast(u63, reg_off.off); |
| 569 | if (reg_off.off == wip_nav.cfi.cfa.off) { | 570 | if (reg_off.off == wip_nav.cfi.cfa.off) { |
| 570 | if (changed_reg) { | 571 | if (changed_reg) { |
| 571 | try dfw.writeByte(DW.CFA.def_cfa_register); | 572 | try df_w.writeByte(DW.CFA.def_cfa_register); |
| 572 | try dfw.writeUleb128(reg_off.reg); | 573 | try df_w.writeUleb128(reg_off.reg); |
| 573 | } | 574 | } |
| 574 | } else if (switch (wip_nav.dwarf.frame.header.data_alignment_factor) { | 575 | } else if (switch (wip_nav.dwarf.frame.header.data_alignment_factor) { |
| 575 | 0 => unreachable, | 576 | 0 => unreachable, |
| 576 | 1 => unsigned_off != null, | 577 | 1 => unsigned_off != null, |
| 577 | else => |data_alignment_factor| @rem(reg_off.off, data_alignment_factor) != 0, | 578 | else => |data_alignment_factor| @rem(reg_off.off, data_alignment_factor) != 0, |
| 578 | }) { | 579 | }) { |
| 579 | try dfw.writeByte(if (changed_reg) DW.CFA.def_cfa else DW.CFA.def_cfa_offset); | 580 | try df_w.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 | if (changed_reg) try df_w.writeUleb128(reg_off.reg); |
| 581 | try dfw.writeUleb128(unsigned_off.?); | 582 | try df_w.writeUleb128(unsigned_off.?); |
| 582 | } else { | 583 | } else { |
| 583 | try dfw.writeByte(if (changed_reg) DW.CFA.def_cfa_sf else DW.CFA.def_cfa_offset_sf); | 584 | try df_w.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 | if (changed_reg) try df_w.writeUleb128(reg_off.reg); |
| 585 | try dfw.writeSleb128( | 586 | try df_w.writeSleb128( |
| 586 | @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor), | 587 | @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor), |
| 587 | ); | 588 | ); |
| 588 | } | 589 | } |
| 589 | wip_nav.cfi.cfa = reg_off; | 590 | wip_nav.cfi.cfa = reg_off; |
| 590 | }, | 591 | }, |
| 591 | .def_cfa_expression => |expr| { | 592 | .def_cfa_expression => |expr| { |
| 592 | try dfw.writeByte(DW.CFA.def_cfa_expression); | 593 | try df_w.writeByte(DW.CFA.def_cfa_expression); |
| 593 | try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, expr); | 594 | try wip_nav.dwarf.exprLoc(df_nw, expr); |
| 594 | }, | 595 | }, |
| 595 | .expression => |reg_expr| { | 596 | .expression => |reg_expr| { |
| 596 | try dfw.writeByte(DW.CFA.expression); | 597 | try df_w.writeByte(DW.CFA.expression); |
| 597 | try dfw.writeUleb128(reg_expr.reg); | 598 | try df_w.writeUleb128(reg_expr.reg); |
| 598 | try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, reg_expr.expr); | 599 | try wip_nav.dwarf.exprLoc(df_nw, reg_expr.expr); |
| 599 | }, | 600 | }, |
| 600 | .val_offset => |reg_off| { | 601 | .val_offset => |reg_off| { |
| 601 | const factored_off = | 602 | const factored_off = |
| 602 | @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor); | 603 | @divExact(reg_off.off, wip_nav.dwarf.frame.header.data_alignment_factor); |
| 603 | if (std.math.cast(u63, factored_off)) |unsigned_off| { | 604 | if (std.math.cast(u63, factored_off)) |unsigned_off| { |
| 604 | try dfw.writeByte(DW.CFA.val_offset); | 605 | try df_w.writeByte(DW.CFA.val_offset); |
| 605 | try dfw.writeUleb128(reg_off.reg); | 606 | try df_w.writeUleb128(reg_off.reg); |
| 606 | try dfw.writeUleb128(unsigned_off); | 607 | try df_w.writeUleb128(unsigned_off); |
| 607 | } else { | 608 | } else { |
| 608 | try dfw.writeByte(DW.CFA.val_offset_sf); | 609 | try df_w.writeByte(DW.CFA.val_offset_sf); |
| 609 | try dfw.writeUleb128(reg_off.reg); | 610 | try df_w.writeUleb128(reg_off.reg); |
| 610 | try dfw.writeSleb128(factored_off); | 611 | try df_w.writeSleb128(factored_off); |
| 611 | } | 612 | } |
| 612 | }, | 613 | }, |
| 613 | .val_expression => |reg_expr| { | 614 | .val_expression => |reg_expr| { |
| 614 | try dfw.writeByte(DW.CFA.val_expression); | 615 | try df_w.writeByte(DW.CFA.val_expression); |
| 615 | try dfw.writeUleb128(reg_expr.reg); | 616 | try df_w.writeUleb128(reg_expr.reg); |
| 616 | try wip_nav.dwarf.exprLoc(&wip_nav.fde_writer, reg_expr.expr); | 617 | try wip_nav.dwarf.exprLoc(df_nw, reg_expr.expr); |
| 617 | }, | 618 | }, |
| 618 | .escape => |bytes| try dfw.writeAll(bytes), | 619 | .escape => |bytes| try df_w.writeAll(bytes), |
| 619 | } | 620 | } |
| 620 | } | 621 | } |
| 621 | }; | 622 | }; |
| ... | @@ -679,15 +680,15 @@ pub const WipNav = struct { | ... | @@ -679,15 +680,15 @@ pub const WipNav = struct { |
| 679 | const target = &zf.mod.?.resolved_target.result; | 680 | const target = &zf.mod.?.resolved_target.result; |
| 680 | const decl = zf.zir.?.getDeclaration(inst_info.inst); | 681 | const decl = zf.zir.?.getDeclaration(inst_info.inst); |
| 681 | const di_nw = &debug.info_writer; | 682 | const di_nw = &debug.info_writer; |
| 682 | const diw = &di_nw.interface; | 683 | const di_w = &di_nw.interface; |
| 683 | try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_func)); | 684 | try dwarf.abbrevCode(di_nw, .decl_func); |
| 684 | try dwarf.refType(pt, di_nw, .fromInterned(ip.namespacePtr(switch (func.generic_owner) { | 685 | try dwarf.refType(pt, di_nw, .fromInterned(ip.namespacePtr(switch (func.generic_owner) { |
| 685 | .none => nav, | 686 | .none => nav, |
| 686 | else => |generic_owner| ip.getNav(zcu.funcInfo(generic_owner).owner_nav), | 687 | else => |generic_owner| ip.getNav(zcu.funcInfo(generic_owner).owner_nav), |
| 687 | }.analysis.?.namespace).owner_type)); | 688 | }.analysis.?.namespace).owner_type)); |
| 688 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 689 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 689 | try diw.writeUleb128(decl.src_column + 1); | 690 | try di_w.writeUleb128(decl.src_column + 1); |
| 690 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 691 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 691 | try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); | 692 | try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); |
| 692 | try dwarf.strp(&dwarf.debug_str, di_nw, switch (decl.linkage) { | 693 | try dwarf.strp(&dwarf.debug_str, di_nw, switch (decl.linkage) { |
| 693 | .normal => nav.fqn, | 694 | .normal => nav.fqn, |
| ... | @@ -695,13 +696,13 @@ pub const WipNav = struct { | ... | @@ -695,13 +696,13 @@ pub const WipNav = struct { |
| 695 | }.toSlice(ip)); | 696 | }.toSlice(ip)); |
| 696 | try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type)); | 697 | try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type)); |
| 697 | try dwarf.addrSym(di_nw, debug.wip_nav.func_si, 0); | 698 | try dwarf.addrSym(di_nw, debug.wip_nav.func_si, 0); |
| 698 | debug.info_func_length_offset = diw.end; | 699 | debug.info_func_length_offset = di_w.end; |
| 699 | try diw.writeInt(u32, undefined, dwarf.endian); | 700 | try di_w.writeInt(u32, undefined, dwarf.endian); |
| 700 | try diw.writeUleb128( | 701 | try di_w.writeUleb128( |
| 701 | target_info.minFunctionAlignment(target).max(nav.resolved.?.@"align").toByteUnits().?, | 702 | target_info.minFunctionAlignment(target).max(nav.resolved.?.@"align").toByteUnits().?, |
| 702 | ); | 703 | ); |
| 703 | try diw.writeByte(@intFromBool(decl.linkage != .normal)); | 704 | try di_w.writeByte(@intFromBool(decl.linkage != .normal)); |
| 704 | try diw.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu))); | 705 | try di_w.writeByte(@intFromBool(Type.fromInterned(func_type.return_type).isNoReturn(zcu))); |
| 705 | } | 706 | } |
| 706 | | 707 | |
| 707 | pub fn startDebugLine(debug: *Debug) link.Error!void { | 708 | pub fn startDebugLine(debug: *Debug) link.Error!void { |
| ... | @@ -719,29 +720,30 @@ pub const WipNav = struct { | ... | @@ -719,29 +720,30 @@ pub const WipNav = struct { |
| 719 | const inst_info = ip.getNav(func.owner_nav).srcInst(ip).resolveFull(ip).?; | 720 | const inst_info = ip.getNav(func.owner_nav).srcInst(ip).resolveFull(ip).?; |
| 720 | const zf = zcu.fileByIndex(inst_info.file); | 721 | const zf = zcu.fileByIndex(inst_info.file); |
| 721 | const decl = zf.zir.?.getDeclaration(inst_info.inst); | 722 | const decl = zf.zir.?.getDeclaration(inst_info.inst); |
| 722 | const dlw = &debug.line_writer.interface; | 723 | const dl_nw = &debug.line_writer; |
| 723 | try dlw.writeByte(DW.LNS.extended_op); | 724 | const dl_w = &dl_nw.interface; |
| | 725 | try dl_w.writeByte(DW.LNS.extended_op); |
| 724 | if (zcu.comp.config.incremental) { | 726 | if (zcu.comp.config.incremental) { |
| 725 | try dlw.writeUleb128(1 + dwarf.secOffsetSize()); | 727 | try dl_w.writeUleb128(1 + dwarf.secOffsetSize()); |
| 726 | try dlw.writeByte(DW.LNE.ZIG_set_decl); | 728 | try dl_w.writeByte(DW.LNE.ZIG_set_decl); |
| 727 | try dwarf.secOffset(&debug.line_writer, debug.info_writer.ni, 0); | 729 | try dwarf.secOffset(dl_nw, debug.info_writer.ni, 0); |
| 728 | | 730 | |
| 729 | try dlw.writeByte(DW.LNS.set_column); | 731 | try dl_w.writeByte(DW.LNS.set_column); |
| 730 | try dlw.writeUleb128(func.lbrace_column + 1); | 732 | try dl_w.writeUleb128(func.lbrace_column + 1); |
| 731 | | 733 | |
| 732 | try debug.advanceLineAndPc(func.lbrace_line, 0, false); | 734 | try debug.advanceLineAndPc(func.lbrace_line, 0, false); |
| 733 | } else { | 735 | } else { |
| 734 | try dlw.writeUleb128(1 + @backingInt(dwarf.address_size)); | 736 | try dl_w.writeUleb128(1 + @backingInt(dwarf.address_size)); |
| 735 | try dlw.writeByte(DW.LNE.set_address); | 737 | try dl_w.writeByte(DW.LNE.set_address); |
| 736 | try dwarf.addrSym(&debug.line_writer, debug.wip_nav.func_si, 0); | 738 | try dwarf.addrSym(dl_nw, debug.wip_nav.func_si, 0); |
| 737 | | 739 | |
| 738 | const unit = dwarf.getUnit(zf.mod.?); | 740 | const unit = dwarf.getUnit(zf.mod.?); |
| 739 | _, const fi = try unit.get(dwarf).getFile(zcu.gpa, unit, inst_info.file); | 741 | _, const fi = try unit.get(dwarf).getFile(zcu.gpa, unit, inst_info.file); |
| 740 | try dlw.writeByte(DW.LNS.set_file); | 742 | try dl_w.writeByte(DW.LNS.set_file); |
| 741 | try dlw.writeUleb128(@backingInt(fi)); | 743 | try dl_w.writeUleb128(@backingInt(fi)); |
| 742 | | 744 | |
| 743 | try dlw.writeByte(DW.LNS.set_column); | 745 | try dl_w.writeByte(DW.LNS.set_column); |
| 744 | try dlw.writeUleb128(func.lbrace_column + 1); | 746 | try dl_w.writeUleb128(func.lbrace_column + 1); |
| 745 | | 747 | |
| 746 | try debug.advanceLineAndPc(decl.src_line + func.lbrace_line, 0, false); | 748 | try debug.advanceLineAndPc(decl.src_line + func.lbrace_line, 0, false); |
| 747 | } | 749 | } |
| ... | @@ -749,30 +751,31 @@ pub const WipNav = struct { | ... | @@ -749,30 +751,31 @@ pub const WipNav = struct { |
| 749 | | 751 | |
| 750 | pub fn finishFunc(debug: *Debug, func_length: u64) link.Error!void { | 752 | pub fn finishFunc(debug: *Debug, func_length: u64) link.Error!void { |
| 751 | assert(debug.wip_nav.func != .none); | 753 | assert(debug.wip_nav.func != .none); |
| | 754 | const di_nw = &debug.info_writer; |
| 752 | debug.finishDebugInfo(func_length) catch |err| switch (err) { | 755 | 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), |
| 754 | else => |e| return e, | 757 | else => |e| return e, |
| 755 | }; | 758 | }; |
| 756 | debug.finishDebugLine() catch |err| switch (err) { | 759 | 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), |
| 758 | else => |e| return e, | 761 | else => |e| return e, |
| 759 | }; | 762 | }; |
| 760 | } | 763 | } |
| 761 | fn finishDebugInfo(debug: *Debug, func_length: u64) link.EmitError!void { | 764 | fn finishDebugInfo(debug: *Debug, func_length: u64) link.EmitError!void { |
| 762 | const dwarf = debug.wip_nav.dwarf; | 765 | const dwarf = debug.wip_nav.dwarf; |
| 763 | const diw = &debug.info_writer.interface; | 766 | const di_w = &debug.info_writer.interface; |
| 764 | std.mem.writeInt( | 767 | std.mem.writeInt( |
| 765 | u32, | 768 | u32, |
| 766 | diw.buffered()[debug.info_func_length_offset..][0..4], | 769 | di_w.buffered()[debug.info_func_length_offset..][0..4], |
| 767 | @intCast(func_length), | 770 | @intCast(func_length), |
| 768 | dwarf.endian, | 771 | dwarf.endian, |
| 769 | ); | 772 | ); |
| 770 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 773 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 771 | try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen()); | 774 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); |
| 772 | } | 775 | } |
| 773 | fn finishDebugLine(debug: *Debug) link.EmitError!void { | 776 | fn finishDebugLine(debug: *Debug) link.EmitError!void { |
| 774 | const dlw = &debug.line_writer.interface; | 777 | const dl_w = &debug.line_writer.interface; |
| 775 | try genDebugLinePadding(dlw, dlw.unusedCapacityLen()); | 778 | try genDebugLinePadding(dl_w, dl_w.unusedCapacityLen()); |
| 776 | } | 779 | } |
| 777 | | 780 | |
| 778 | pub const LocalVarTag = enum { arg, local_var }; | 781 | pub const LocalVarTag = enum { arg, local_var }; |
| ... | @@ -798,13 +801,13 @@ pub const WipNav = struct { | ... | @@ -798,13 +801,13 @@ pub const WipNav = struct { |
| 798 | assert(debug.wip_nav.func != .none); | 801 | assert(debug.wip_nav.func != .none); |
| 799 | const dwarf = debug.wip_nav.dwarf; | 802 | const dwarf = debug.wip_nav.dwarf; |
| 800 | const di_nw = &debug.info_writer; | 803 | 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) { |
| 802 | .arg => if (opt_name) |_| .arg else .unnamed_arg, | 805 | .arg => if (opt_name) |_| .arg else .unnamed_arg, |
| 803 | .local_var => if (opt_name) |_| .local_var else unreachable, | 806 | .local_var => if (opt_name) |_| .local_var else unreachable, |
| 804 | })); | 807 | }); |
| 805 | if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name); | 808 | if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 806 | try dwarf.refType(debug.pt, di_nw, ty); | 809 | try dwarf.refType(debug.pt, di_nw, ty); |
| 807 | try dwarf.exprLoc(&debug.info_writer, loc); | 810 | try dwarf.exprLoc(di_nw, loc); |
| 808 | debug.any_children = true; | 811 | debug.any_children = true; |
| 809 | } | 812 | } |
| 810 | | 813 | |
| ... | @@ -833,7 +836,7 @@ pub const WipNav = struct { | ... | @@ -833,7 +836,7 @@ pub const WipNav = struct { |
| 833 | const ty = val.typeOf(zcu); | 836 | const ty = val.typeOf(zcu); |
| 834 | const ty_class = ty.classify(zcu); | 837 | const ty_class = ty.classify(zcu); |
| 835 | const di_nw = &debug.info_writer; | 838 | 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) { |
| 837 | .comptime_arg => if (opt_name) |_| switch (ty_class) { | 840 | .comptime_arg => if (opt_name) |_| switch (ty_class) { |
| 838 | .no_possible_value => unreachable, | 841 | .no_possible_value => unreachable, |
| 839 | .one_possible_value => .comptime_arg, | 842 | .one_possible_value => .comptime_arg, |
| ... | @@ -854,7 +857,7 @@ pub const WipNav = struct { | ... | @@ -854,7 +857,7 @@ pub const WipNav = struct { |
| 854 | .partially_comptime => .local_const_partially_comptime, | 857 | .partially_comptime => .local_const_partially_comptime, |
| 855 | .fully_comptime => .local_const_fully_comptime, | 858 | .fully_comptime => .local_const_fully_comptime, |
| 856 | } else unreachable, | 859 | } else unreachable, |
| 857 | })); | 860 | }); |
| 858 | if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name); | 861 | if (opt_name) |name| try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 859 | try dwarf.refType(pt, di_nw, ty); | 862 | try dwarf.refType(pt, di_nw, ty); |
| 860 | if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, val); | 863 | if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, val); |
| ... | @@ -870,7 +873,7 @@ pub const WipNav = struct { | ... | @@ -870,7 +873,7 @@ pub const WipNav = struct { |
| 870 | } | 873 | } |
| 871 | fn genVarArgsDebugInfoInner(debug: *Debug) link.EmitError!void { | 874 | fn genVarArgsDebugInfoInner(debug: *Debug) link.EmitError!void { |
| 872 | assert(debug.wip_nav.func != .none); | 875 | 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); |
| 874 | debug.any_children = true; | 877 | debug.any_children = true; |
| 875 | } | 878 | } |
| 876 | | 879 | |
| ... | @@ -890,7 +893,7 @@ pub const WipNav = struct { | ... | @@ -890,7 +893,7 @@ pub const WipNav = struct { |
| 890 | delta_pc: u64, | 893 | delta_pc: u64, |
| 891 | end: bool, | 894 | end: bool, |
| 892 | ) std.Io.Writer.Error!void { | 895 | ) std.Io.Writer.Error!void { |
| 893 | const dlw = &debug.line_writer.interface; | 896 | const dl_w = &debug.line_writer.interface; |
| 894 | | 897 | |
| 895 | const header = debug.wip_nav.dwarf.debug_line.header; | 898 | const header = debug.wip_nav.dwarf.debug_line.header; |
| 896 | assert(header.maximum_operations_per_instruction == 1); | 899 | assert(header.maximum_operations_per_instruction == 1); |
| ... | @@ -900,8 +903,8 @@ pub const WipNav = struct { | ... | @@ -900,8 +903,8 @@ pub const WipNav = struct { |
| 900 | delta_line - header.line_base >= header.line_range) | 903 | delta_line - header.line_base >= header.line_range) |
| 901 | remaining: { | 904 | remaining: { |
| 902 | assert(delta_line != 0); | 905 | assert(delta_line != 0); |
| 903 | try dlw.writeByte(DW.LNS.advance_line); | 906 | try dl_w.writeByte(DW.LNS.advance_line); |
| 904 | try dlw.writeSleb128(delta_line); | 907 | try dl_w.writeSleb128(delta_line); |
| 905 | break :remaining 0; | 908 | break :remaining 0; |
| 906 | } else delta_line); | 909 | } else delta_line); |
| 907 | | 910 | |
| ... | @@ -912,26 +915,26 @@ pub const WipNav = struct { | ... | @@ -912,26 +915,26 @@ pub const WipNav = struct { |
| 912 | op_advance >= 2 * max_op_advance) | 915 | op_advance >= 2 * max_op_advance) |
| 913 | remaining: { | 916 | remaining: { |
| 914 | if (op_advance == max_op_advance) { | 917 | 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); |
| 916 | } else if (op_advance != 0) { | 919 | } else if (op_advance != 0) { |
| 917 | try dlw.writeByte(DW.LNS.advance_pc); | 920 | try dl_w.writeByte(DW.LNS.advance_pc); |
| 918 | try dlw.writeUleb128(op_advance); | 921 | try dl_w.writeUleb128(op_advance); |
| 919 | } else assert(end); | 922 | } else assert(end); |
| 920 | break :remaining 0; | 923 | break :remaining 0; |
| 921 | } else if (op_advance >= max_op_advance) remaining: { | 924 | } 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); |
| 923 | break :remaining op_advance - max_op_advance; | 926 | break :remaining op_advance - max_op_advance; |
| 924 | } else op_advance); | 927 | } else op_advance); |
| 925 | | 928 | |
| 926 | if (remaining_delta_line != 0 or remaining_op_advance != 0) { | 929 | if (remaining_delta_line != 0 or remaining_op_advance != 0) { |
| 927 | assert(!end); | 930 | 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) + |
| 929 | (header.line_range * remaining_op_advance) + header.opcode_base)); | 932 | (header.line_range * remaining_op_advance) + header.opcode_base)); |
| 930 | } else if (end) { | 933 | } else if (end) { |
| 931 | try dlw.writeByte(DW.LNS.extended_op); | 934 | try dl_w.writeByte(DW.LNS.extended_op); |
| 932 | try dlw.writeUleb128(1); | 935 | try dl_w.writeUleb128(1); |
| 933 | try dlw.writeByte(DW.LNE.end_sequence); | 936 | try dl_w.writeByte(DW.LNE.end_sequence); |
| 934 | } else try dlw.writeByte(DW.LNS.copy); | 937 | } else try dl_w.writeByte(DW.LNS.copy); |
| 935 | } | 938 | } |
| 936 | | 939 | |
| 937 | pub fn setColumn(debug: *Debug, column: u32) link.Error!void { | 940 | pub fn setColumn(debug: *Debug, column: u32) link.Error!void { |
| ... | @@ -940,9 +943,9 @@ pub const WipNav = struct { | ... | @@ -940,9 +943,9 @@ pub const WipNav = struct { |
| 940 | }; | 943 | }; |
| 941 | } | 944 | } |
| 942 | fn setColumnInner(debug: *Debug, column: u32) std.Io.Writer.Error!void { | 945 | fn setColumnInner(debug: *Debug, column: u32) std.Io.Writer.Error!void { |
| 943 | const dlw = &debug.line_writer.interface; | 946 | const dl_w = &debug.line_writer.interface; |
| 944 | try dlw.writeByte(DW.LNS.set_column); | 947 | try dl_w.writeByte(DW.LNS.set_column); |
| 945 | try dlw.writeUleb128(column + 1); | 948 | try dl_w.writeUleb128(column + 1); |
| 946 | } | 949 | } |
| 947 | | 950 | |
| 948 | pub fn negateStmt(debug: *Debug) link.Error!void { | 951 | pub fn negateStmt(debug: *Debug) link.Error!void { |
| ... | @@ -982,13 +985,14 @@ pub const WipNav = struct { | ... | @@ -982,13 +985,14 @@ pub const WipNav = struct { |
| 982 | const dwarf = debug.wip_nav.dwarf; | 985 | const dwarf = debug.wip_nav.dwarf; |
| 983 | const block = try debug.blocks.addOne(dwarf.lf.comp.gpa); | 986 | const block = try debug.blocks.addOne(dwarf.lf.comp.gpa); |
| 984 | | 987 | |
| 985 | const diw = &debug.info_writer.interface; | 988 | const di_nw = &debug.info_writer; |
| 986 | block.abbrev_code = @intCast(diw.end); | 989 | const di_w = &di_nw.interface; |
| 987 | try diw.writeUleb128(try dwarf.refAbbrevCode(.block)); | 990 | block.abbrev_code = @intCast(di_w.end); |
| | 991 | try dwarf.abbrevCode(di_nw, .block); |
| 988 | block.low_pc_off = code_off; | 992 | block.low_pc_off = code_off; |
| 989 | try dwarf.addrSym(&debug.info_writer, debug.wip_nav.func_si, code_off); | 993 | try dwarf.addrSym(di_nw, debug.wip_nav.func_si, code_off); |
| 990 | block.high_pc = @intCast(diw.end); | 994 | block.high_pc = @intCast(di_w.end); |
| 991 | try diw.writeInt(u32, 0, dwarf.endian); | 995 | try di_w.writeInt(u32, 0, dwarf.endian); |
| 992 | debug.any_children = false; | 996 | debug.any_children = false; |
| 993 | } | 997 | } |
| 994 | | 998 | |
| ... | @@ -1002,17 +1006,20 @@ pub const WipNav = struct { | ... | @@ -1002,17 +1006,20 @@ pub const WipNav = struct { |
| 1002 | const dwarf = debug.wip_nav.dwarf; | 1006 | const dwarf = debug.wip_nav.dwarf; |
| 1003 | const block_size = comptime uleb128Size(@backingInt(AbbrevCode.block)); | 1007 | const block_size = comptime uleb128Size(@backingInt(AbbrevCode.block)); |
| 1004 | const block = debug.blocks.pop().?; | 1008 | const block = debug.blocks.pop().?; |
| | 1009 | |
| | 1010 | const di_nw = &debug.info_writer; |
| | 1011 | const di_w = &di_nw.interface; |
| 1005 | if (debug.any_children) | 1012 | if (debug.any_children) |
| 1006 | try debug.info_writer.interface.writeUleb128(@backingInt(AbbrevCode.null)) | 1013 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)) |
| 1007 | else | 1014 | else |
| 1008 | std.leb.writeUnsignedFixed( | 1015 | std.leb.writeUnsignedFixed( |
| 1009 | block_size, | 1016 | block_size, |
| 1010 | debug.info_writer.interface.buffered()[block.abbrev_code..][0..block_size], | 1017 | di_w.buffered()[block.abbrev_code..][0..block_size], |
| 1011 | @intCast(try dwarf.refAbbrevCode(.empty_block)), | 1018 | @intCast(try dwarf.refAbbrevCode(di_nw.mf, .empty_block)), |
| 1012 | ); | 1019 | ); |
| 1013 | std.mem.writeInt( | 1020 | std.mem.writeInt( |
| 1014 | u32, | 1021 | u32, |
| 1015 | debug.info_writer.interface.buffered()[block.high_pc..][0..4], | 1022 | di_nw.interface.buffered()[block.high_pc..][0..4], |
| 1016 | @intCast(code_off - block.low_pc_off), | 1023 | @intCast(code_off - block.low_pc_off), |
| 1017 | dwarf.endian, | 1024 | dwarf.endian, |
| 1018 | ); | 1025 | ); |
| ... | @@ -1042,20 +1049,21 @@ pub const WipNav = struct { | ... | @@ -1042,20 +1049,21 @@ pub const WipNav = struct { |
| 1042 | const zcu = debug.pt.zcu; | 1049 | const zcu = debug.pt.zcu; |
| 1043 | const block = try debug.blocks.addOne(zcu.gpa); | 1050 | const block = try debug.blocks.addOne(zcu.gpa); |
| 1044 | | 1051 | |
| 1045 | const diw = &debug.info_writer.interface; | 1052 | const di_nw = &debug.info_writer; |
| 1046 | block.abbrev_code = @intCast(diw.end); | 1053 | const di_w = &di_nw.interface; |
| 1047 | try diw.writeUleb128(try dwarf.refAbbrevCode(.inlined_func)); | 1054 | block.abbrev_code = @intCast(di_w.end); |
| | 1055 | try dwarf.abbrevCode(di_nw, .inlined_func); |
| 1048 | try debug.refFunc(func); | 1056 | try debug.refFunc(func); |
| 1049 | try diw.writeUleb128((if (zcu.comp.config.incremental) | 1057 | try di_w.writeUleb128((if (zcu.comp.config.incremental) |
| 1050 | 0 | 1058 | 0 |
| 1051 | else | 1059 | else |
| 1052 | zcu.navSrcLine(zcu.funcInfo(debug.wip_nav.func).owner_nav) + 1) + line); | 1060 | zcu.navSrcLine(zcu.funcInfo(debug.wip_nav.func).owner_nav) + 1) + line); |
| 1053 | try diw.writeUleb128(line); | 1061 | try di_w.writeUleb128(line); |
| 1054 | try diw.writeUleb128(column + 1); | 1062 | try di_w.writeUleb128(column + 1); |
| 1055 | block.low_pc_off = code_off; | 1063 | block.low_pc_off = code_off; |
| 1056 | try dwarf.addrSym(&debug.info_writer, debug.wip_nav.func_si, code_off); | 1064 | try dwarf.addrSym(di_nw, debug.wip_nav.func_si, code_off); |
| 1057 | block.high_pc = @intCast(diw.end); | 1065 | block.high_pc = @intCast(di_w.end); |
| 1058 | try diw.writeInt(u32, 0, dwarf.endian); | 1066 | try di_w.writeInt(u32, 0, dwarf.endian); |
| 1059 | try debug.setInlineFunc(func); | 1067 | try debug.setInlineFunc(func); |
| 1060 | debug.any_children = false; | 1068 | debug.any_children = false; |
| 1061 | } | 1069 | } |
| ... | @@ -1074,18 +1082,20 @@ pub const WipNav = struct { | ... | @@ -1074,18 +1082,20 @@ pub const WipNav = struct { |
| 1074 | const dwarf = debug.wip_nav.dwarf; | 1082 | const dwarf = debug.wip_nav.dwarf; |
| 1075 | const inlined_func_size = comptime uleb128Size(@backingInt(AbbrevCode.inlined_func)); | 1083 | const inlined_func_size = comptime uleb128Size(@backingInt(AbbrevCode.inlined_func)); |
| 1076 | const block = debug.blocks.pop().?; | 1084 | 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; |
| 1078 | if (debug.any_children) | 1088 | if (debug.any_children) |
| 1079 | try diw.writeUleb128(@backingInt(AbbrevCode.null)) | 1089 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)) |
| 1080 | else | 1090 | else |
| 1081 | std.leb.writeUnsignedFixed( | 1091 | std.leb.writeUnsignedFixed( |
| 1082 | inlined_func_size, | 1092 | inlined_func_size, |
| 1083 | diw.buffered()[block.abbrev_code..][0..inlined_func_size], | 1093 | di_w.buffered()[block.abbrev_code..][0..inlined_func_size], |
| 1084 | @intCast(try dwarf.refAbbrevCode(.empty_inlined_func)), | 1094 | @intCast(try dwarf.refAbbrevCode(di_nw.mf, .empty_inlined_func)), |
| 1085 | ); | 1095 | ); |
| 1086 | std.mem.writeInt( | 1096 | std.mem.writeInt( |
| 1087 | u32, | 1097 | u32, |
| 1088 | diw.buffered()[block.high_pc..][0..4], | 1098 | di_w.buffered()[block.high_pc..][0..4], |
| 1089 | @intCast(code_off - block.low_pc_off), | 1099 | @intCast(code_off - block.low_pc_off), |
| 1090 | dwarf.endian, | 1100 | dwarf.endian, |
| 1091 | ); | 1101 | ); |
| ... | @@ -1105,18 +1115,15 @@ pub const WipNav = struct { | ... | @@ -1105,18 +1115,15 @@ pub const WipNav = struct { |
| 1105 | const dwarf = debug.wip_nav.dwarf; | 1115 | const dwarf = debug.wip_nav.dwarf; |
| 1106 | if (debug.wip_nav.func == func) return; | 1116 | if (debug.wip_nav.func == func) return; |
| 1107 | | 1117 | |
| | 1118 | const dl_nw = &debug.line_writer; |
| | 1119 | const dl_w = &dl_nw.interface; |
| 1108 | const new_owner_nav = zcu.funcInfo(func).owner_nav; | 1120 | const new_owner_nav = zcu.funcInfo(func).owner_nav; |
| 1109 | const dlw = &debug.line_writer.interface; | | |
| 1110 | if (zcu.comp.config.incremental) { | 1121 | if (zcu.comp.config.incremental) { |
| 1111 | const new_func = try dwarf.getFunc(new_owner_nav); | 1122 | const new_func = try dwarf.getFunc(new_owner_nav); |
| 1112 | try dlw.writeByte(DW.LNS.extended_op); | 1123 | try dl_w.writeByte(DW.LNS.extended_op); |
| 1113 | try dlw.writeUleb128(1 + dwarf.secOffsetSize()); | 1124 | try dl_w.writeUleb128(1 + dwarf.secOffsetSize()); |
| 1114 | try dlw.writeByte(DW.LNE.ZIG_set_decl); | 1125 | try dl_w.writeByte(DW.LNE.ZIG_set_decl); |
| 1115 | try dwarf.secOffset( | 1126 | try dwarf.secOffset(dl_nw, new_func.get(dwarf).debug_info_ni.unwrap().?, 0); |
| 1116 | &debug.line_writer, | | |
| 1117 | new_func.get(dwarf).debug_info_ni.unwrap().?, | | |
| 1118 | 0, | | |
| 1119 | ); | | |
| 1120 | return; | 1127 | return; |
| 1121 | } | 1128 | } |
| 1122 | | 1129 | |
| ... | @@ -1130,15 +1137,15 @@ pub const WipNav = struct { | ... | @@ -1130,15 +1137,15 @@ pub const WipNav = struct { |
| 1130 | _, const new_fi = | 1137 | _, const new_fi = |
| 1131 | try debug.wip_nav.unit.get(dwarf).getFile(zcu.gpa, new_ui, new_inst_info.file); | 1138 | try debug.wip_nav.unit.get(dwarf).getFile(zcu.gpa, new_ui, new_inst_info.file); |
| 1132 | | 1139 | |
| 1133 | try dlw.writeByte(DW.LNS.set_file); | 1140 | try dl_w.writeByte(DW.LNS.set_file); |
| 1134 | try dlw.writeUleb128(@backingInt(new_fi)); | 1141 | try dl_w.writeUleb128(@backingInt(new_fi)); |
| 1135 | } | 1142 | } |
| 1136 | | 1143 | |
| 1137 | const old_src_line: i33 = old_zf.zir.?.getDeclaration(old_inst_info.inst).src_line; | 1144 | const old_src_line: i33 = old_zf.zir.?.getDeclaration(old_inst_info.inst).src_line; |
| 1138 | const new_src_line: i33 = new_zf.zir.?.getDeclaration(new_inst_info.inst).src_line; | 1145 | const new_src_line: i33 = new_zf.zir.?.getDeclaration(new_inst_info.inst).src_line; |
| 1139 | if (new_src_line != old_src_line) { | 1146 | if (new_src_line != old_src_line) { |
| 1140 | try dlw.writeByte(DW.LNS.advance_line); | 1147 | try dl_w.writeByte(DW.LNS.advance_line); |
| 1141 | try dlw.writeSleb128(new_src_line - old_src_line); | 1148 | try dl_w.writeSleb128(new_src_line - old_src_line); |
| 1142 | } | 1149 | } |
| 1143 | | 1150 | |
| 1144 | debug.wip_nav.func = func; | 1151 | debug.wip_nav.func = func; |
| ... | @@ -1169,32 +1176,32 @@ pub const WipNav = struct { | ... | @@ -1169,32 +1176,32 @@ pub const WipNav = struct { |
| 1169 | fn genDebugFrameHeaderInner(wip_nav: *WipNav) link.EmitError!void { | 1176 | fn genDebugFrameHeaderInner(wip_nav: *WipNav) link.EmitError!void { |
| 1170 | assert(wip_nav.func != .none); | 1177 | assert(wip_nav.func != .none); |
| 1171 | const dwarf = wip_nav.dwarf; | 1178 | const dwarf = wip_nav.dwarf; |
| 1172 | const dfw = &wip_nav.fde_writer.interface; | 1179 | const df_nw = &wip_nav.fde_writer; |
| 1173 | try dwarf.genUnitLength(dfw); | 1180 | const df_w = &df_nw.interface; |
| | 1181 | try dwarf.genUnitLength(df_w); |
| 1174 | switch (wip_nav.frame_format) { | 1182 | switch (wip_nav.frame_format) { |
| 1175 | .eh_frame => { | 1183 | .eh_frame => { |
| 1176 | try dfw.writeInt(u32, undefined, dwarf.endian); | 1184 | try df_w.writeInt(u32, undefined, dwarf.endian); |
| 1177 | { | 1185 | { |
| 1178 | const offset = dfw.end; | 1186 | const offset = df_w.end; |
| 1179 | try dfw.writeInt(u32, 0, dwarf.endian); | 1187 | try df_w.writeInt(u32, 0, dwarf.endian); |
| 1180 | const elf = dwarf.lf.cast(.elf2).?; | 1188 | if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc( |
| 1181 | try elf.addReloc( | 1189 | @bitCast(df_nw.ni), |
| 1182 | @bitCast(wip_nav.fde_writer.ni), | | |
| 1183 | offset, | 1190 | offset, |
| 1184 | wip_nav.func_si, | 1191 | wip_nav.func_si, |
| 1185 | 0, | 1192 | 0, |
| 1186 | .rel32(elf), | 1193 | .rel32(elf), |
| 1187 | ); | 1194 | ) else unreachable; |
| 1188 | } | 1195 | } |
| 1189 | wip_nav.frame_func_length = .{ .offset = dfw.end, .size = .@"32" }; | 1196 | wip_nav.frame_func_length = .{ .offset = df_w.end, .size = .@"32" }; |
| 1190 | try dfw.writeInt(u32, undefined, dwarf.endian); | 1197 | try df_w.writeInt(u32, undefined, dwarf.endian); |
| 1191 | try dfw.writeUleb128(0); | 1198 | try df_w.writeUleb128(0); |
| 1192 | }, | 1199 | }, |
| 1193 | .debug_frame => { | 1200 | .debug_frame => { |
| 1194 | try dwarf.secOffset(&wip_nav.fde_writer, wip_nav.unit.get(dwarf).cie_ni.unwrap().?, 0); | 1201 | try dwarf.secOffset(df_nw, wip_nav.unit.get(dwarf).cie_ni.unwrap().?, 0); |
| 1195 | try dwarf.addrSym(&wip_nav.fde_writer, wip_nav.func_si, 0); | 1202 | try dwarf.addrSym(df_nw, wip_nav.func_si, 0); |
| 1196 | wip_nav.frame_func_length = .{ .offset = dfw.end, .size = dwarf.address_size }; | 1203 | wip_nav.frame_func_length = .{ .offset = df_w.end, .size = dwarf.address_size }; |
| 1197 | try dwarf.addrPlaceholder(dfw); | 1204 | try dwarf.addrPlaceholder(df_w); |
| 1198 | }, | 1205 | }, |
| 1199 | } | 1206 | } |
| 1200 | } | 1207 | } |
| ... | @@ -1214,23 +1221,23 @@ pub const WipNav = struct { | ... | @@ -1214,23 +1221,23 @@ pub const WipNav = struct { |
| 1214 | | 1221 | |
| 1215 | pub fn finishDebugFrameFde(wip_nav: *WipNav, func_length: u64) void { | 1222 | pub fn finishDebugFrameFde(wip_nav: *WipNav, func_length: u64) void { |
| 1216 | const dwarf = wip_nav.dwarf; | 1223 | const dwarf = wip_nav.dwarf; |
| 1217 | const dfw = &wip_nav.fde_writer.interface; | 1224 | const df_w = &wip_nav.fde_writer.interface; |
| 1218 | switch (wip_nav.frame_func_length.size) { | 1225 | switch (wip_nav.frame_func_length.size) { |
| 1219 | _ => unreachable, | 1226 | _ => unreachable, |
| 1220 | .@"32" => std.mem.writeInt( | 1227 | .@"32" => std.mem.writeInt( |
| 1221 | u32, | 1228 | u32, |
| 1222 | dfw.buffered()[wip_nav.frame_func_length.offset..][0..4], | 1229 | df_w.buffered()[wip_nav.frame_func_length.offset..][0..4], |
| 1223 | @intCast(func_length), | 1230 | @intCast(func_length), |
| 1224 | dwarf.endian, | 1231 | dwarf.endian, |
| 1225 | ), | 1232 | ), |
| 1226 | .@"64" => std.mem.writeInt( | 1233 | .@"64" => std.mem.writeInt( |
| 1227 | u64, | 1234 | u64, |
| 1228 | dfw.buffered()[wip_nav.frame_func_length.offset..][0..8], | 1235 | df_w.buffered()[wip_nav.frame_func_length.offset..][0..8], |
| 1229 | func_length, | 1236 | func_length, |
| 1230 | dwarf.endian, | 1237 | dwarf.endian, |
| 1231 | ), | 1238 | ), |
| 1232 | } | 1239 | } |
| 1233 | @memset(dfw.unusedCapacitySlice(), DW.CFA.nop); | 1240 | @memset(df_w.unusedCapacitySlice(), DW.CFA.nop); |
| 1234 | } | 1241 | } |
| 1235 | }; | 1242 | }; |
| 1236 | | 1243 | |
| ... | @@ -1596,32 +1603,31 @@ pub fn genEhFrameHdr( | ... | @@ -1596,32 +1603,31 @@ pub fn genEhFrameHdr( |
| 1596 | .table_enc = .omit, | 1603 | .table_enc = .omit, |
| 1597 | .eh_frame_ptr = undefined, | 1604 | .eh_frame_ptr = undefined, |
| 1598 | }; | 1605 | }; |
| 1599 | const elf = dwarf.lf.cast(.elf2).?; | 1606 | if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc( |
| 1600 | try elf.addReloc( | | |
| 1601 | eh_frame_hdr_ai, | 1607 | eh_frame_hdr_ai, |
| 1602 | @offsetOf(EhFrameHdr, "eh_frame_ptr"), | 1608 | @offsetOf(EhFrameHdr, "eh_frame_ptr"), |
| 1603 | eh_frame_si, | 1609 | eh_frame_si, |
| 1604 | 0, | 1610 | 0, |
| 1605 | .rel32(elf), | 1611 | .rel32(elf), |
| 1606 | ); | 1612 | ) else unreachable; |
| 1607 | } | 1613 | } |
| 1608 | | 1614 | |
| 1609 | pub fn genDebugFrameCie( | 1615 | pub fn genDebugFrameCie( |
| 1610 | dwarf: *Dwarf, | 1616 | dwarf: *Dwarf, |
| 1611 | dfw: *std.Io.Writer, | 1617 | df_w: *std.Io.Writer, |
| 1612 | /// `null` means to generate an architecture-agnostic padding cie | 1618 | /// `null` means to generate an architecture-agnostic padding cie |
| 1613 | arch: ?std.Target.Cpu.Arch, | 1619 | arch: ?std.Target.Cpu.Arch, |
| 1614 | format: Frame.Format, | 1620 | format: Frame.Format, |
| 1615 | ) std.Io.Writer.Error!void { | 1621 | ) std.Io.Writer.Error!void { |
| 1616 | try dwarf.genUnitLength(dfw); | 1622 | try dwarf.genUnitLength(df_w); |
| 1617 | switch (format) { | 1623 | switch (format) { |
| 1618 | .eh_frame => try dfw.writeInt(u32, 0, dwarf.endian), | 1624 | .eh_frame => try df_w.writeInt(u32, 0, dwarf.endian), |
| 1619 | .debug_frame => switch (dwarf.format) { | 1625 | .debug_frame => switch (dwarf.format) { |
| 1620 | .@"32" => try dfw.writeInt(u32, std.math.maxInt(u32), dwarf.endian), | 1626 | .@"32" => try df_w.writeInt(u32, std.math.maxInt(u32), dwarf.endian), |
| 1621 | .@"64" => try dfw.writeInt(u64, std.math.maxInt(u64), dwarf.endian), | 1627 | .@"64" => try df_w.writeInt(u64, std.math.maxInt(u64), dwarf.endian), |
| 1622 | }, | 1628 | }, |
| 1623 | } | 1629 | } |
| 1624 | try dfw.writeByte(if (arch) |_| switch (format) { | 1630 | try df_w.writeByte(if (arch) |_| switch (format) { |
| 1625 | .eh_frame => 1, | 1631 | .eh_frame => 1, |
| 1626 | .debug_frame => 4, | 1632 | .debug_frame => 4, |
| 1627 | } else 0); | 1633 | } else 0); |
| ... | @@ -1631,34 +1637,34 @@ pub fn genDebugFrameCie( | ... | @@ -1631,34 +1637,34 @@ pub fn genDebugFrameCie( |
| 1631 | dev.check(.x86_64_backend); | 1637 | dev.check(.x86_64_backend); |
| 1632 | const Register = @import("../codegen/x86_64/bits.zig").Register; | 1638 | const Register = @import("../codegen/x86_64/bits.zig").Register; |
| 1633 | switch (format) { | 1639 | switch (format) { |
| 1634 | .eh_frame => try dfw.writeAll("zR\x00"), | 1640 | .eh_frame => try df_w.writeAll("zR\x00"), |
| 1635 | .debug_frame => { | 1641 | .debug_frame => { |
| 1636 | try dfw.writeAll("\x00"); | 1642 | try df_w.writeAll("\x00"); |
| 1637 | try dfw.writeByte(@backingInt(dwarf.address_size)); | 1643 | try df_w.writeByte(@backingInt(dwarf.address_size)); |
| 1638 | try dfw.writeByte(0); | 1644 | try df_w.writeByte(0); |
| 1639 | }, | 1645 | }, |
| 1640 | } | 1646 | } |
| 1641 | try dfw.writeUleb128(dwarf.frame.header.code_alignment_factor); | 1647 | try df_w.writeUleb128(dwarf.frame.header.code_alignment_factor); |
| 1642 | try dfw.writeSleb128(dwarf.frame.header.data_alignment_factor); | 1648 | try df_w.writeSleb128(dwarf.frame.header.data_alignment_factor); |
| 1643 | switch (format) { | 1649 | switch (format) { |
| 1644 | .eh_frame => try dfw.writeByte(@intCast(dwarf.frame.header.return_address_register)), | 1650 | .eh_frame => try df_w.writeByte(@intCast(dwarf.frame.header.return_address_register)), |
| 1645 | .debug_frame => try dfw.writeUleb128(dwarf.frame.header.return_address_register), | 1651 | .debug_frame => try df_w.writeUleb128(dwarf.frame.header.return_address_register), |
| 1646 | } | 1652 | } |
| 1647 | switch (format) { | 1653 | switch (format) { |
| 1648 | .eh_frame => { | 1654 | .eh_frame => { |
| 1649 | try dfw.writeUleb128(1); | 1655 | try df_w.writeUleb128(1); |
| 1650 | try dfw.writeByte(@bitCast(@as(DW.EH.PE, .{ .type = .sdata4, .rel = .pcrel }))); | 1656 | try df_w.writeByte(@bitCast(@as(DW.EH.PE, .{ .type = .sdata4, .rel = .pcrel }))); |
| 1651 | }, | 1657 | }, |
| 1652 | .debug_frame => {}, | 1658 | .debug_frame => {}, |
| 1653 | } | 1659 | } |
| 1654 | try dfw.writeByte(DW.CFA.def_cfa_sf); | 1660 | try df_w.writeByte(DW.CFA.def_cfa_sf); |
| 1655 | try dfw.writeUleb128(Register.rsp.dwarfNum()); | 1661 | try df_w.writeUleb128(Register.rsp.dwarfNum()); |
| 1656 | try dfw.writeSleb128(-1); | 1662 | try df_w.writeSleb128(-1); |
| 1657 | try dfw.writeByte(@as(u8, DW.CFA.offset) + Register.rip.dwarfNum()); | 1663 | try df_w.writeByte(@as(u8, DW.CFA.offset) + Register.rip.dwarfNum()); |
| 1658 | try dfw.writeUleb128(1); | 1664 | try df_w.writeUleb128(1); |
| 1659 | }, | 1665 | }, |
| 1660 | } | 1666 | } |
| 1661 | @memset(dfw.unusedCapacitySlice(), DW.CFA.nop); | 1667 | @memset(df_w.unusedCapacitySlice(), DW.CFA.nop); |
| 1662 | } | 1668 | } |
| 1663 | | 1669 | |
| 1664 | pub fn updateEhFrameFde(dwarf: *Dwarf, fde: []u8, fde_offset: u64) void { | 1670 | pub fn updateEhFrameFde(dwarf: *Dwarf, fde: []u8, fde_offset: u64) void { |
| ... | @@ -1679,16 +1685,16 @@ pub fn genDebugInfoHeader( | ... | @@ -1679,16 +1685,16 @@ pub fn genDebugInfoHeader( |
| 1679 | dih_nw: *MappedFile.Node.Writer, | 1685 | dih_nw: *MappedFile.Node.Writer, |
| 1680 | ) link.EmitError!void { | 1686 | ) link.EmitError!void { |
| 1681 | const comp = zcu.comp; | 1687 | const comp = zcu.comp; |
| 1682 | const dihw = &dih_nw.interface; | 1688 | const dih_w = &dih_nw.interface; |
| 1683 | if (!unit.alive) return dwarf.genUnitPadding(dihw); | 1689 | if (!unit.alive) return dwarf.genUnitPadding(dih_w); |
| 1684 | try dwarf.genUnitLength(dihw); | 1690 | try dwarf.genUnitLength(dih_w); |
| 1685 | try dihw.writeInt(u16, 5, dwarf.endian); | 1691 | try dih_w.writeInt(u16, 5, dwarf.endian); |
| 1686 | try dihw.writeByte(DW.UT.compile); | 1692 | try dih_w.writeByte(DW.UT.compile); |
| 1687 | try dihw.writeByte(@backingInt(dwarf.address_size)); | 1693 | try dih_w.writeByte(@backingInt(dwarf.address_size)); |
| 1688 | try dwarf.secOffset(dih_nw, dwarf.debug_abbrev.ni.unwrap().?, 0); | 1694 | try dwarf.secOffset(dih_nw, dwarf.debug_abbrev.ni.unwrap().?, 0); |
| 1689 | const compile_unit_offset = dihw.end; | 1695 | const compile_unit_offset = dih_w.end; |
| 1690 | try dihw.writeUleb128(try dwarf.refAbbrevCode(.compile_unit)); | 1696 | try dwarf.abbrevCode(dih_nw, .compile_unit); |
| 1691 | try dihw.writeByte(DW.LANG.Zig); | 1697 | try dih_w.writeByte(DW.LANG.Zig); |
| 1692 | try dwarf.strp(&dwarf.debug_str, dih_nw, "zig " ++ @import("build_options").version); | 1698 | try dwarf.strp(&dwarf.debug_str, dih_nw, "zig " ++ @import("build_options").version); |
| 1693 | const root_dir_path = try mod.root.toAbsolute(&comp.dirs, comp.gpa); | 1699 | const root_dir_path = try mod.root.toAbsolute(&comp.dirs, comp.gpa); |
| 1694 | defer comp.gpa.free(root_dir_path); | 1700 | defer comp.gpa.free(root_dir_path); |
| ... | @@ -1701,11 +1707,11 @@ pub fn genDebugInfoHeader( | ... | @@ -1701,11 +1707,11 @@ pub fn genDebugInfoHeader( |
| 1701 | ); | 1707 | ); |
| 1702 | try dwarf.secOffset(dih_nw, unit.debug_line_header_ni.unwrap().?, 0); | 1708 | try dwarf.secOffset(dih_nw, unit.debug_line_header_ni.unwrap().?, 0); |
| 1703 | try dwarf.secOffset(dih_nw, unit.debug_rnglists_ni.unwrap().?, Rnglists.offsetsTableOffset(dwarf)); | 1709 | try dwarf.secOffset(dih_nw, unit.debug_rnglists_ni.unwrap().?, Rnglists.offsetsTableOffset(dwarf)); |
| 1704 | try dihw.writeUleb128(0); | 1710 | try dih_w.writeUleb128(0); |
| 1705 | const module_offset = dihw.end; | 1711 | const module_offset = dih_w.end; |
| 1706 | try dihw.writeUleb128(try dwarf.refAbbrevCode(.module)); | 1712 | try dwarf.abbrevCode(dih_nw, .module); |
| 1707 | try dwarf.strp(&dwarf.debug_str, dih_nw, mod.fully_qualified_name); | 1713 | try dwarf.strp(&dwarf.debug_str, dih_nw, mod.fully_qualified_name); |
| 1708 | try dihw.writeUleb128(0); | 1714 | try dih_w.writeUleb128(0); |
| 1709 | try dwarf.genModuleDependency( | 1715 | try dwarf.genModuleDependency( |
| 1710 | dih_nw, | 1716 | dih_nw, |
| 1711 | "builtin", | 1717 | "builtin", |
| ... | @@ -1716,8 +1722,8 @@ pub fn genDebugInfoHeader( | ... | @@ -1716,8 +1722,8 @@ pub fn genDebugInfoHeader( |
| 1716 | try dwarf.genModuleDependency(dih_nw, "std", zcu.std_mod, module_offset); | 1722 | try dwarf.genModuleDependency(dih_nw, "std", zcu.std_mod, module_offset); |
| 1717 | for (mod.deps.keys(), mod.deps.values()) |name, dep| | 1723 | for (mod.deps.keys(), mod.deps.values()) |name, dep| |
| 1718 | try dwarf.genModuleDependency(dih_nw, name, dep, module_offset); | 1724 | try dwarf.genModuleDependency(dih_nw, name, dep, module_offset); |
| 1719 | for ([2]AbbrevCode{ .pad_1, .pad_n }) |pad| _ = try dwarf.refAbbrevCode(pad); | 1725 | for ([2]AbbrevCode{ .pad_1, .pad_n }) |pad| _ = try dwarf.refAbbrevCode(dih_nw.mf, pad); |
| 1720 | try dwarf.genDebugInfoPadding(dihw, dihw.unusedCapacityLen()); | 1726 | try dwarf.genDebugInfoPadding(dih_w, dih_w.unusedCapacityLen()); |
| 1721 | } | 1727 | } |
| 1722 | | 1728 | |
| 1723 | fn genModuleDependency( | 1729 | fn genModuleDependency( |
| ... | @@ -1729,27 +1735,33 @@ fn genModuleDependency( | ... | @@ -1729,27 +1735,33 @@ fn genModuleDependency( |
| 1729 | ) link.EmitError!void { | 1735 | ) link.EmitError!void { |
| 1730 | const dep_unit = dwarf.getUnit(dep).get(dwarf); | 1736 | const dep_unit = dwarf.getUnit(dep).get(dwarf); |
| 1731 | if (!dep_unit.alive) return; | 1737 | if (!dep_unit.alive) return; |
| 1732 | const diw = &di_nw.interface; | 1738 | try dwarf.abbrevCode(di_nw, .module_dependency); |
| 1733 | try diw.writeUleb128(try dwarf.refAbbrevCode(.module_dependency)); | | |
| 1734 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 1739 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 1735 | try dwarf.secOffset(di_nw, dep_unit.debug_info_header_ni.unwrap().?, module_offset); | 1740 | try dwarf.secOffset(di_nw, dep_unit.debug_info_header_ni.unwrap().?, module_offset); |
| 1736 | } | 1741 | } |
| 1737 | | 1742 | |
| 1738 | pub fn genDebugInfoPadding(dwarf: *Dwarf, diw: *std.Io.Writer, size: u64) std.Io.Writer.Error!void { | 1743 | pub fn genDebugInfoPadding(dwarf: *Dwarf, di_w: *std.Io.Writer, size: u64) std.Io.Writer.Error!void { |
| 1739 | switch (size) { | 1744 | switch (size) { |
| 1740 | 0 => {}, | 1745 | 0 => {}, |
| 1741 | 1 => try diw.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_1).?), | 1746 | 1 => try di_w.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_1).?), |
| 1742 | else => { | 1747 | else => { |
| 1743 | const abbrev_code_offset = diw.end; | 1748 | const abbrev_code_offset = di_w.end; |
| 1744 | try diw.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_n).?); | 1749 | try di_w.writeUleb128(dwarf.refAbbrevCodeIfExists(.pad_n).?); |
| 1745 | const abbrev_code_size = diw.end - abbrev_code_offset; | 1750 | const abbrev_code_size = di_w.end - abbrev_code_offset; |
| 1746 | var block_len_size: u5 = 1; | 1751 | 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)) { | 1752 | while (true) switch (std.math.order( |
| 1748 | .lt => break try diw.writeUleb128(size - abbrev_code_size - block_len_size), | 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), |
| 1749 | .eq => { | 1757 | .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 |
| 1751 | block_len_size += 1; | 1760 | 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 | ); |
| 1753 | break; | 1765 | break; |
| 1754 | }, | 1766 | }, |
| 1755 | .gt => block_len_size += 1, | 1767 | .gt => block_len_size += 1, |
| ... | @@ -1765,19 +1777,19 @@ pub fn genDebugLineHeader( | ... | @@ -1765,19 +1777,19 @@ pub fn genDebugLineHeader( |
| 1765 | zcu: *Zcu, | 1777 | zcu: *Zcu, |
| 1766 | ) link.EmitError!void { | 1778 | ) link.EmitError!void { |
| 1767 | const comp = zcu.comp; | 1779 | const comp = zcu.comp; |
| 1768 | const dlhw = &dlh_nw.interface; | 1780 | const dlh_w = &dlh_nw.interface; |
| 1769 | try dwarf.genUnitLength(dlhw); | 1781 | try dwarf.genUnitLength(dlh_w); |
| 1770 | try dlhw.writeInt(u16, 5, dwarf.endian); | 1782 | try dlh_w.writeInt(u16, 5, dwarf.endian); |
| 1771 | try dlhw.writeByte(@backingInt(dwarf.address_size)); | 1783 | try dlh_w.writeByte(@backingInt(dwarf.address_size)); |
| 1772 | try dlhw.writeByte(0); | 1784 | try dlh_w.writeByte(0); |
| 1773 | const header_length_offset = dlhw.end; | 1785 | const header_length_offset = dlh_w.end; |
| 1774 | switch (dwarf.format) { | 1786 | switch (dwarf.format) { |
| 1775 | .@"32" => try dlhw.writeInt(u32, undefined, dwarf.endian), | 1787 | .@"32" => try dlh_w.writeInt(u32, undefined, dwarf.endian), |
| 1776 | .@"64" => try dlhw.writeInt(u64, undefined, dwarf.endian), | 1788 | .@"64" => try dlh_w.writeInt(u64, undefined, dwarf.endian), |
| 1777 | } | 1789 | } |
| 1778 | const header_start = dlhw.end; | 1790 | const header_start = dlh_w.end; |
| 1779 | const StandardOpcode = DeclValEnum(DW.LNS); | 1791 | const StandardOpcode = DeclValEnum(DW.LNS); |
| 1780 | try dlhw.writeAll(&.{ | 1792 | try dlh_w.writeAll(&.{ |
| 1781 | dwarf.debug_line.header.minimum_instruction_length, | 1793 | dwarf.debug_line.header.minimum_instruction_length, |
| 1782 | dwarf.debug_line.header.maximum_operations_per_instruction, | 1794 | dwarf.debug_line.header.maximum_operations_per_instruction, |
| 1783 | @intFromBool(dwarf.debug_line.header.default_is_stmt), | 1795 | @intFromBool(dwarf.debug_line.header.default_is_stmt), |
| ... | @@ -1785,7 +1797,7 @@ pub fn genDebugLineHeader( | ... | @@ -1785,7 +1797,7 @@ pub fn genDebugLineHeader( |
| 1785 | dwarf.debug_line.header.line_range, | 1797 | dwarf.debug_line.header.line_range, |
| 1786 | dwarf.debug_line.header.opcode_base, | 1798 | dwarf.debug_line.header.opcode_base, |
| 1787 | }); | 1799 | }); |
| 1788 | try dlhw.writeAll(std.enums.EnumArray(StandardOpcode, u8).init(.{ | 1800 | try dlh_w.writeAll(std.enums.EnumArray(StandardOpcode, u8).init(.{ |
| 1789 | .extended_op = undefined, | 1801 | .extended_op = undefined, |
| 1790 | .copy = 0, | 1802 | .copy = 0, |
| 1791 | .advance_pc = 1, | 1803 | .advance_pc = 1, |
| ... | @@ -1800,9 +1812,9 @@ pub fn genDebugLineHeader( | ... | @@ -1800,9 +1812,9 @@ pub fn genDebugLineHeader( |
| 1800 | .set_epilogue_begin = 0, | 1812 | .set_epilogue_begin = 0, |
| 1801 | .set_isa = 1, | 1813 | .set_isa = 1, |
| 1802 | }).values[1..dwarf.debug_line.header.opcode_base]); | 1814 | }).values[1..dwarf.debug_line.header.opcode_base]); |
| 1803 | try dlhw.writeByte(1); | 1815 | try dlh_w.writeByte(1); |
| 1804 | try dlhw.writeUleb128(DW.LNCT.path); | 1816 | try dlh_w.writeUleb128(DW.LNCT.path); |
| 1805 | try dlhw.writeUleb128(DW.FORM.line_strp); | 1817 | try dlh_w.writeUleb128(DW.FORM.line_strp); |
| 1806 | const dir_count = unit.dirs.count(); | 1818 | const dir_count = unit.dirs.count(); |
| 1807 | const directory_index_form: DeclValEnum(DW.FORM) = if (dir_count <= 1 << 8) | 1819 | const directory_index_form: DeclValEnum(DW.FORM) = if (dir_count <= 1 << 8) |
| 1808 | .data1 | 1820 | .data1 |
| ... | @@ -1810,24 +1822,24 @@ pub fn genDebugLineHeader( | ... | @@ -1810,24 +1822,24 @@ pub fn genDebugLineHeader( |
| 1810 | .data2 | 1822 | .data2 |
| 1811 | else | 1823 | else |
| 1812 | .udata; | 1824 | .udata; |
| 1813 | try dlhw.writeUleb128(dir_count); | 1825 | try dlh_w.writeUleb128(dir_count); |
| 1814 | for (unit.dirs.keys()) |ui| { | 1826 | for (unit.dirs.keys()) |ui| { |
| 1815 | const root_dir_path = try ui.mod(dwarf).root.toAbsolute(&zcu.comp.dirs, comp.gpa); | 1827 | const root_dir_path = try ui.mod(dwarf).root.toAbsolute(&zcu.comp.dirs, comp.gpa); |
| 1816 | defer comp.gpa.free(root_dir_path); | 1828 | defer comp.gpa.free(root_dir_path); |
| 1817 | try dwarf.strp(&dwarf.debug_line_str, dlh_nw, root_dir_path); | 1829 | try dwarf.strp(&dwarf.debug_line_str, dlh_nw, root_dir_path); |
| 1818 | } | 1830 | } |
| 1819 | try dlhw.writeByte(5); | 1831 | try dlh_w.writeByte(5); |
| 1820 | try dlhw.writeUleb128(DW.LNCT.path); | 1832 | try dlh_w.writeUleb128(DW.LNCT.path); |
| 1821 | try dlhw.writeUleb128(DW.FORM.line_strp); | 1833 | try dlh_w.writeUleb128(DW.FORM.line_strp); |
| 1822 | try dlhw.writeUleb128(DW.LNCT.directory_index); | 1834 | try dlh_w.writeUleb128(DW.LNCT.directory_index); |
| 1823 | try dlhw.writeUleb128(@backingInt(directory_index_form)); | 1835 | try dlh_w.writeUleb128(@backingInt(directory_index_form)); |
| 1824 | try dlhw.writeUleb128(DW.LNCT.timestamp); | 1836 | try dlh_w.writeUleb128(DW.LNCT.timestamp); |
| 1825 | try dlhw.writeUleb128(DW.FORM.data8); | 1837 | try dlh_w.writeUleb128(DW.FORM.data8); |
| 1826 | try dlhw.writeUleb128(DW.LNCT.size); | 1838 | try dlh_w.writeUleb128(DW.LNCT.size); |
| 1827 | try dlhw.writeUleb128(DW.FORM.data8); | 1839 | try dlh_w.writeUleb128(DW.FORM.data8); |
| 1828 | try dlhw.writeUleb128(DW.LNCT.LLVM_source); | 1840 | try dlh_w.writeUleb128(DW.LNCT.LLVM_source); |
| 1829 | try dlhw.writeUleb128(DW.FORM.line_strp); | 1841 | try dlh_w.writeUleb128(DW.FORM.line_strp); |
| 1830 | try dlhw.writeUleb128(unit.files.count()); | 1842 | try dlh_w.writeUleb128(unit.files.count()); |
| 1831 | for (unit.files.keys()) |zfi| { | 1843 | for (unit.files.keys()) |zfi| { |
| 1832 | const zf = zcu.fileByIndex(zfi); | 1844 | const zf = zcu.fileByIndex(zfi); |
| 1833 | try dwarf.strp(&dwarf.debug_line_str, dlh_nw, zf.sub_file_path); | 1845 | try dwarf.strp(&dwarf.debug_line_str, dlh_nw, zf.sub_file_path); |
| ... | @@ -1835,12 +1847,12 @@ pub fn genDebugLineHeader( | ... | @@ -1835,12 +1847,12 @@ pub fn genDebugLineHeader( |
| 1835 | if (zcu.alive_files.contains(zfi)) unit.dirs.getIndex(dwarf.getUnit(zf.mod.?)).? else 0; | 1847 | if (zcu.alive_files.contains(zfi)) unit.dirs.getIndex(dwarf.getUnit(zf.mod.?)).? else 0; |
| 1836 | switch (directory_index_form) { | 1848 | switch (directory_index_form) { |
| 1837 | else => unreachable, | 1849 | else => unreachable, |
| 1838 | .data1 => try dlhw.writeByte(@intCast(di)), | 1850 | .data1 => try dlh_w.writeByte(@intCast(di)), |
| 1839 | .data2 => try dlhw.writeInt(u16, @intCast(di), dwarf.endian), | 1851 | .data2 => try dlh_w.writeInt(u16, @intCast(di), dwarf.endian), |
| 1840 | .udata => try dlhw.writeUleb128(di), | 1852 | .udata => try dlh_w.writeUleb128(di), |
| 1841 | } | 1853 | } |
| 1842 | try dlhw.writeInt(i64, @truncate(zf.stat.mtime.nanoseconds), dwarf.endian); | 1854 | try dlh_w.writeInt(i64, @truncate(zf.stat.mtime.nanoseconds), dwarf.endian); |
| 1843 | try dlhw.writeInt(u64, zf.stat.size, dwarf.endian); | 1855 | try dlh_w.writeInt(u64, zf.stat.size, dwarf.endian); |
| 1844 | try dwarf.strp( | 1856 | try dwarf.strp( |
| 1845 | &dwarf.debug_line_str, | 1857 | &dwarf.debug_line_str, |
| 1846 | dlh_nw, | 1858 | dlh_nw, |
| ... | @@ -1850,41 +1862,48 @@ pub fn genDebugLineHeader( | ... | @@ -1850,41 +1862,48 @@ pub fn genDebugLineHeader( |
| 1850 | switch (dwarf.format) { | 1862 | switch (dwarf.format) { |
| 1851 | .@"32" => std.mem.writeInt( | 1863 | .@"32" => std.mem.writeInt( |
| 1852 | u32, | 1864 | u32, |
| 1853 | dlhw.buffer[header_length_offset..][0..4], | 1865 | dlh_w.buffer[header_length_offset..][0..4], |
| 1854 | @intCast(dlhw.end - header_start), | 1866 | @intCast(dlh_w.end - header_start), |
| 1855 | dwarf.endian, | 1867 | dwarf.endian, |
| 1856 | ), | 1868 | ), |
| 1857 | .@"64" => std.mem.writeInt( | 1869 | .@"64" => std.mem.writeInt( |
| 1858 | u64, | 1870 | u64, |
| 1859 | dlhw.buffer[header_length_offset..][0..8], | 1871 | dlh_w.buffer[header_length_offset..][0..8], |
| 1860 | dlhw.end - header_start, | 1872 | dlh_w.end - header_start, |
| 1861 | dwarf.endian, | 1873 | dwarf.endian, |
| 1862 | ), | 1874 | ), |
| 1863 | } | 1875 | } |
| 1864 | try genDebugLinePadding(dlhw, dlhw.unusedCapacityLen()); | 1876 | try genDebugLinePadding(dlh_w, dlh_w.unusedCapacityLen()); |
| 1865 | } | 1877 | } |
| 1866 | | 1878 | |
| 1867 | pub fn genDebugLinePadding(dlw: *std.Io.Writer, size: u64) std.Io.Writer.Error!void { | 1879 | pub fn genDebugLinePadding(dl_w: *std.Io.Writer, size: u64) std.Io.Writer.Error!void { |
| 1868 | switch (size) { | 1880 | switch (size) { |
| 1869 | 0 => {}, | 1881 | 0 => {}, |
| 1870 | 1 => try dlw.writeByte(DW.LNS.const_add_pc), | 1882 | 1 => try dl_w.writeByte(DW.LNS.const_add_pc), |
| 1871 | 2 => try dlw.writeAll(&.{ DW.LNS.negate_stmt, DW.LNS.negate_stmt }), | 1883 | 2 => try dl_w.writeAll(&.{ DW.LNS.negate_stmt, DW.LNS.negate_stmt }), |
| 1872 | else => { | 1884 | else => { |
| 1873 | const extended_op_offset = dlw.end; | 1885 | const extended_op_offset = dl_w.end; |
| 1874 | try dlw.writeByte(DW.LNS.extended_op); | 1886 | try dl_w.writeByte(DW.LNS.extended_op); |
| 1875 | const extended_op_size = dlw.end - extended_op_offset; | 1887 | const extended_op_size = dl_w.end - extended_op_offset; |
| 1876 | var op_len_size: u5 = 1; | 1888 | 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)) { | 1889 | while (true) switch (std.math.order( |
| 1878 | .lt => break try dlw.writeUleb128(size - extended_op_size - op_len_size), | 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), |
| 1879 | .eq => { | 1894 | .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 |
| 1881 | op_len_size += 1; | 1897 | 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 | ); |
| 1883 | break; | 1902 | break; |
| 1884 | }, | 1903 | }, |
| 1885 | .gt => op_len_size += 1, | 1904 | .gt => op_len_size += 1, |
| 1886 | }; | 1905 | }; |
| 1887 | try dlw.writeByte(DW.LNE.padding); | 1906 | try dl_w.writeByte(DW.LNE.padding); |
| 1888 | }, | 1907 | }, |
| 1889 | } | 1908 | } |
| 1890 | } | 1909 | } |
| ... | @@ -1894,19 +1913,19 @@ pub fn genDebugRnglistsHeader( | ... | @@ -1894,19 +1913,19 @@ pub fn genDebugRnglistsHeader( |
| 1894 | unit: *Unit, | 1913 | unit: *Unit, |
| 1895 | drh_nw: *MappedFile.Node.Writer, | 1914 | drh_nw: *MappedFile.Node.Writer, |
| 1896 | ) std.Io.Writer.Error!void { | 1915 | ) std.Io.Writer.Error!void { |
| 1897 | const drhw = &drh_nw.interface; | 1916 | const drh_w = &drh_nw.interface; |
| 1898 | try dwarf.genUnitLength(drhw); | 1917 | try dwarf.genUnitLength(drh_w); |
| 1899 | try drhw.writeInt(u16, 5, dwarf.endian); | 1918 | try drh_w.writeInt(u16, 5, dwarf.endian); |
| 1900 | try drhw.writeByte(@backingInt(dwarf.address_size)); | 1919 | try drh_w.writeByte(@backingInt(dwarf.address_size)); |
| 1901 | try drhw.writeByte(0); | 1920 | try drh_w.writeByte(0); |
| 1902 | try drhw.writeInt(u32, 1, dwarf.endian); | 1921 | try drh_w.writeInt(u32, 1, dwarf.endian); |
| 1903 | assert(drhw.end == Rnglists.offsetsTableOffset(dwarf)); | 1922 | assert(drh_w.end == Rnglists.offsetsTableOffset(dwarf)); |
| 1904 | switch (dwarf.format) { | 1923 | switch (dwarf.format) { |
| 1905 | .@"32" => try drhw.writeInt(u32, 4, dwarf.endian), | 1924 | .@"32" => try drh_w.writeInt(u32, 4, dwarf.endian), |
| 1906 | .@"64" => try drhw.writeInt(u64, 8, dwarf.endian), | 1925 | .@"64" => try drh_w.writeInt(u64, 8, dwarf.endian), |
| 1907 | } | 1926 | } |
| 1908 | unit.debug_rnglists_end = drhw.end; | 1927 | unit.debug_rnglists_end = drh_w.end; |
| 1909 | try drhw.writeByte(DW.RLE.end_of_list); | 1928 | try drh_w.writeByte(DW.RLE.end_of_list); |
| 1910 | } | 1929 | } |
| 1911 | | 1930 | |
| 1912 | pub fn genDebugRnglists( | 1931 | pub fn genDebugRnglists( |
| ... | @@ -1916,13 +1935,13 @@ pub fn genDebugRnglists( | ... | @@ -1916,13 +1935,13 @@ pub fn genDebugRnglists( |
| 1916 | func_si: link.File.SymbolId, | 1935 | func_si: link.File.SymbolId, |
| 1917 | func_length: u64, | 1936 | func_length: u64, |
| 1918 | ) link.EmitError!void { | 1937 | ) link.EmitError!void { |
| 1919 | const drw = &dr_nw.interface; | 1938 | const dr_w = &dr_nw.interface; |
| 1920 | drw.end = unit.debug_rnglists_end; | 1939 | dr_w.end = unit.debug_rnglists_end; |
| 1921 | try drw.writeByte(DW.RLE.start_length); | 1940 | try dr_w.writeByte(DW.RLE.start_length); |
| 1922 | try dwarf.addrSym(dr_nw, func_si, 0); | 1941 | try dwarf.addrSym(dr_nw, func_si, 0); |
| 1923 | try drw.writeUleb128(func_length); | 1942 | try dr_w.writeUleb128(func_length); |
| 1924 | unit.debug_rnglists_end = drw.end; | 1943 | unit.debug_rnglists_end = dr_w.end; |
| 1925 | try drw.writeByte(DW.RLE.end_of_list); | 1944 | try dr_w.writeByte(DW.RLE.end_of_list); |
| 1926 | } | 1945 | } |
| 1927 | | 1946 | |
| 1928 | pub fn updateComptimeNav( | 1947 | pub fn updateComptimeNav( |
| ... | @@ -2054,95 +2073,107 @@ fn updateConstInner( | ... | @@ -2054,95 +2073,107 @@ fn updateConstInner( |
| 2054 | ) link.EmitError!void { | 2073 | ) link.EmitError!void { |
| 2055 | const zcu = pt.zcu; | 2074 | const zcu = pt.zcu; |
| 2056 | const ip = &zcu.intern_pool; | 2075 | const ip = &zcu.intern_pool; |
| 2057 | const diw = &di_nw.interface; | 2076 | const di_w = &di_nw.interface; |
| 2058 | switch (ip.indexToKey(val)) { | 2077 | switch (ip.indexToKey(val)) { |
| 2059 | .int_type => |int_type| { | 2078 | .int_type => |int_type| { |
| 2060 | const ty: Type = .fromInterned(val); | 2079 | const ty: Type = .fromInterned(val); |
| 2061 | try diw.writeUleb128(try dwarf.refAbbrevCode(.numeric_type)); | 2080 | try dwarf.abbrevCode(di_nw, .numeric_type); |
| 2062 | var name_buf: [std.fmt.count("i{d}", .{std.math.maxInt(u16)})]u8 = undefined; | 2081 | 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); | 2082 | try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&name_buf, "{f}", .{ |
| 2064 | try diw.writeByte(switch (int_type.signedness) { | 2083 | ty.fmt(pt), |
| | 2084 | }) catch unreachable); |
| | 2085 | try di_w.writeByte(switch (int_type.signedness) { |
| 2065 | .signed => DW.ATE.signed, | 2086 | .signed => DW.ATE.signed, |
| 2066 | .unsigned => DW.ATE.unsigned, | 2087 | .unsigned => DW.ATE.unsigned, |
| 2067 | }); | 2088 | }); |
| 2068 | try diw.writeUleb128(int_type.bits); | 2089 | try di_w.writeUleb128(int_type.bits); |
| 2069 | try diw.writeUleb128(ty.abiSize(zcu)); | 2090 | try di_w.writeUleb128(ty.abiSize(zcu)); |
| 2070 | try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); | 2091 | try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); |
| 2071 | }, | 2092 | }, |
| 2072 | .ptr_type => |ptr_type| switch (ptr_type.flags.size) { | 2093 | .ptr_type => |ptr_type| switch (ptr_type.flags.size) { |
| 2073 | .one, .many, .c => { | 2094 | .one, .many, .c => { |
| 2074 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2095 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2075 | defer zcu.gpa.free(name); | 2096 | defer zcu.gpa.free(name); |
| 2076 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (ptr_type.flags.alignment) { | 2097 | try dwarf.abbrevCode(di_nw, switch (ptr_type.sentinel) { |
| 2077 | .none => if (ptr_type.sentinel == .none) .ptr_type else .ptr_sentinel_type, | 2098 | .none => switch (ptr_type.flags.alignment) { |
| 2078 | else => if (ptr_type.sentinel == .none) .ptr_aligned_type else .ptr_aligned_sentinel_type, | 2099 | .none => .ptr_type, |
| 2079 | })); | 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 | }); |
| 2080 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2107 | 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)); | 2108 | switch (ptr_type.sentinel) { |
| 2082 | if (ptr_type.flags.alignment.toByteUnits()) |a| try diw.writeUleb128(a); | 2109 | .none => {}, |
| 2083 | try diw.writeByte(@backingInt(ptr_type.flags.address_space)); | 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)); |
| 2084 | if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try dwarf.secOffset( | 2114 | if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try dwarf.secOffset( |
| 2085 | di_nw, | 2115 | di_nw, |
| 2086 | di_nw.ni, | 2116 | di_nw.ni, |
| 2087 | diw.end + dwarf.secOffsetSize(), | 2117 | di_w.end + dwarf.secOffsetSize(), |
| 2088 | ); | 2118 | ); |
| 2089 | if (ptr_type.flags.is_const) { | 2119 | if (ptr_type.flags.is_const) { |
| 2090 | try diw.writeUleb128(try dwarf.refAbbrevCode(.is_const)); | 2120 | try dwarf.abbrevCode(di_nw, .is_const); |
| 2091 | if (ptr_type.flags.is_volatile) try dwarf.secOffset( | 2121 | if (ptr_type.flags.is_volatile) try dwarf.secOffset( |
| 2092 | di_nw, | 2122 | di_nw, |
| 2093 | di_nw.ni, | 2123 | di_nw.ni, |
| 2094 | diw.end + dwarf.secOffsetSize(), | 2124 | di_w.end + dwarf.secOffsetSize(), |
| 2095 | ); | 2125 | ); |
| 2096 | } | 2126 | } |
| 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); |
| 2098 | try dwarf.refType(pt, di_nw, .fromInterned(ptr_type.child)); | 2128 | try dwarf.refType(pt, di_nw, .fromInterned(ptr_type.child)); |
| 2099 | }, | 2129 | }, |
| 2100 | .slice => { | 2130 | .slice => { |
| 2101 | const ty: Type = .fromInterned(val); | 2131 | const ty: Type = .fromInterned(val); |
| 2102 | const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)}); | 2132 | const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)}); |
| 2103 | defer zcu.gpa.free(name); | 2133 | defer zcu.gpa.free(name); |
| 2104 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_struct_type)); | 2134 | try dwarf.abbrevCode(di_nw, .generated_struct_type); |
| 2105 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2135 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2106 | try diw.writeUleb128(ty.abiSize(zcu)); | 2136 | try di_w.writeUleb128(ty.abiSize(zcu)); |
| 2107 | try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); | 2137 | try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); |
| 2108 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2138 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2109 | try dwarf.strp(&dwarf.debug_str, di_nw, "ptr"); | 2139 | try dwarf.strp(&dwarf.debug_str, di_nw, "ptr"); |
| 2110 | const ptr_field_ty = ty.slicePtrFieldType(zcu); | 2140 | const ptr_field_ty = ty.slicePtrFieldType(zcu); |
| 2111 | try dwarf.refType(pt, di_nw, ptr_field_ty); | 2141 | try dwarf.refType(pt, di_nw, ptr_field_ty); |
| 2112 | try diw.writeUleb128(0); | 2142 | try di_w.writeUleb128(0); |
| 2113 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2143 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2114 | try dwarf.strp(&dwarf.debug_str, di_nw, "len"); | 2144 | try dwarf.strp(&dwarf.debug_str, di_nw, "len"); |
| 2115 | const len_field_ty: Type = .usize; | 2145 | const len_field_ty: Type = .usize; |
| 2116 | try dwarf.refType(pt, di_nw, len_field_ty); | 2146 | try dwarf.refType(pt, di_nw, len_field_ty); |
| 2117 | try diw.writeUleb128(len_field_ty.abiAlignment(zcu).forward(ptr_field_ty.abiSize(zcu))); | 2147 | try di_w.writeUleb128(len_field_ty.abiAlignment(zcu).forward(ptr_field_ty.abiSize(zcu))); |
| 2118 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2148 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2119 | }, | 2149 | }, |
| 2120 | }, | 2150 | }, |
| 2121 | .array_type => |array_type| { | 2151 | .array_type => |array_type| { |
| 2122 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2152 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2123 | defer zcu.gpa.free(name); | 2153 | defer zcu.gpa.free(name); |
| 2124 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2154 | try dwarf.abbrevCode( |
| | 2155 | di_nw, |
| 2125 | if (array_type.sentinel == .none) .array_type else .array_sentinel_type, | 2156 | if (array_type.sentinel == .none) .array_type else .array_sentinel_type, |
| 2126 | )); | 2157 | ); |
| 2127 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2158 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2128 | if (array_type.sentinel != .none) | 2159 | if (array_type.sentinel != .none) |
| 2129 | try dwarf.blockConst(pt, di_nw, .fromInterned(array_type.sentinel)); | 2160 | try dwarf.blockConst(pt, di_nw, .fromInterned(array_type.sentinel)); |
| 2130 | try dwarf.refType(pt, di_nw, .fromInterned(array_type.child)); | 2161 | 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); |
| 2132 | try dwarf.refType(pt, di_nw, .usize); | 2163 | try dwarf.refType(pt, di_nw, .usize); |
| 2133 | try diw.writeUleb128(array_type.len); | 2164 | try di_w.writeUleb128(array_type.len); |
| 2134 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2165 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2135 | }, | 2166 | }, |
| 2136 | .vector_type => |vector_type| { | 2167 | .vector_type => |vector_type| { |
| 2137 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2168 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2138 | defer zcu.gpa.free(name); | 2169 | defer zcu.gpa.free(name); |
| 2139 | try diw.writeUleb128(try dwarf.refAbbrevCode(.vector_type)); | 2170 | try dwarf.abbrevCode(di_nw, .vector_type); |
| 2140 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2171 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2141 | try dwarf.refType(pt, di_nw, .fromInterned(vector_type.child)); | 2172 | 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); |
| 2143 | try dwarf.refType(pt, di_nw, .usize); | 2174 | try dwarf.refType(pt, di_nw, .usize); |
| 2144 | try diw.writeUleb128(vector_type.len); | 2175 | try di_w.writeUleb128(vector_type.len); |
| 2145 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2176 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2146 | }, | 2177 | }, |
| 2147 | .opt_type => |opt_child_type_index| { | 2178 | .opt_type => |opt_child_type_index| { |
| 2148 | const opt_ty: Type = .fromInterned(val); | 2179 | const opt_ty: Type = .fromInterned(val); |
| ... | @@ -2150,66 +2181,66 @@ fn updateConstInner( | ... | @@ -2150,66 +2181,66 @@ fn updateConstInner( |
| 2150 | const opt_repr = optRepr(opt_child_ty, zcu); | 2181 | const opt_repr = optRepr(opt_child_ty, zcu); |
| 2151 | const name = try zcu.gpa.print("{f}", .{opt_ty.fmt(pt)}); | 2182 | const name = try zcu.gpa.print("{f}", .{opt_ty.fmt(pt)}); |
| 2152 | defer zcu.gpa.free(name); | 2183 | defer zcu.gpa.free(name); |
| 2153 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_union_type)); | 2184 | try dwarf.abbrevCode(di_nw, .generated_union_type); |
| 2154 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2185 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2155 | try diw.writeUleb128(opt_ty.abiSize(zcu)); | 2186 | try di_w.writeUleb128(opt_ty.abiSize(zcu)); |
| 2156 | try diw.writeUleb128(opt_ty.abiAlignment(zcu).toByteUnits().?); | 2187 | try di_w.writeUleb128(opt_ty.abiAlignment(zcu).toByteUnits().?); |
| 2157 | switch (opt_repr) { | 2188 | switch (opt_repr) { |
| 2158 | .opv_null => { | 2189 | .opv_null => { |
| 2159 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2190 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2160 | try dwarf.strp(&dwarf.debug_str, di_nw, "null"); | 2191 | try dwarf.strp(&dwarf.debug_str, di_nw, "null"); |
| 2161 | try dwarf.refType(pt, di_nw, .null); | 2192 | try dwarf.refType(pt, di_nw, .null); |
| 2162 | try diw.writeUleb128(0); | 2193 | try di_w.writeUleb128(0); |
| 2163 | }, | 2194 | }, |
| 2164 | .unpacked, .error_set, .pointer => { | 2195 | .unpacked, .error_set, .pointer => { |
| 2165 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union)); | 2196 | try dwarf.abbrevCode(di_nw, .tagged_union); |
| 2166 | try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize()); | 2197 | try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize()); |
| 2167 | { | 2198 | { |
| 2168 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2199 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2169 | try dwarf.strp(&dwarf.debug_str, di_nw, "has_value"); | 2200 | try dwarf.strp(&dwarf.debug_str, di_nw, "has_value"); |
| 2170 | switch (opt_repr) { | 2201 | switch (opt_repr) { |
| 2171 | .opv_null => unreachable, | 2202 | .opv_null => unreachable, |
| 2172 | .unpacked => { | 2203 | .unpacked => { |
| 2173 | try dwarf.refType(pt, di_nw, .bool); | 2204 | 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)) |
| 2175 | opt_child_ty.abiSize(zcu) | 2206 | opt_child_ty.abiSize(zcu) |
| 2176 | else | 2207 | else |
| 2177 | 0); | 2208 | 0); |
| 2178 | }, | 2209 | }, |
| 2179 | .error_set => { | 2210 | .error_set => { |
| 2180 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); | 2211 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); |
| 2181 | try diw.writeUleb128(0); | 2212 | try di_w.writeUleb128(0); |
| 2182 | }, | 2213 | }, |
| 2183 | .pointer => { | 2214 | .pointer => { |
| 2184 | try dwarf.refType(pt, di_nw, .usize); | 2215 | try dwarf.refType(pt, di_nw, .usize); |
| 2185 | try diw.writeUleb128(0); | 2216 | try di_w.writeUleb128(0); |
| 2186 | }, | 2217 | }, |
| 2187 | } | 2218 | } |
| 2188 | | 2219 | |
| 2189 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field)); | 2220 | try dwarf.abbrevCode(di_nw, .tagged_union_field); |
| 2190 | try diw.writeUleb128(DW.FORM.data1); | 2221 | try di_w.writeUleb128(DW.FORM.data1); |
| 2191 | try diw.writeByte(0); | 2222 | try di_w.writeByte(0); |
| 2192 | { | 2223 | { |
| 2193 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2224 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2194 | try dwarf.strp(&dwarf.debug_str, di_nw, "null"); | 2225 | try dwarf.strp(&dwarf.debug_str, di_nw, "null"); |
| 2195 | try dwarf.refType(pt, di_nw, .null); | 2226 | try dwarf.refType(pt, di_nw, .null); |
| 2196 | try diw.writeUleb128(0); | 2227 | try di_w.writeUleb128(0); |
| 2197 | } | 2228 | } |
| 2198 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2229 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2199 | | 2230 | |
| 2200 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_default_field)); | 2231 | try dwarf.abbrevCode(di_nw, .tagged_union_default_field); |
| 2201 | { | 2232 | { |
| 2202 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2233 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2203 | try dwarf.strp(&dwarf.debug_str, di_nw, "?"); | 2234 | try dwarf.strp(&dwarf.debug_str, di_nw, "?"); |
| 2204 | try dwarf.refType(pt, di_nw, opt_child_ty); | 2235 | try dwarf.refType(pt, di_nw, opt_child_ty); |
| 2205 | try diw.writeUleb128(0); | 2236 | try di_w.writeUleb128(0); |
| 2206 | } | 2237 | } |
| 2207 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2238 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2208 | } | 2239 | } |
| 2209 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2240 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2210 | }, | 2241 | }, |
| 2211 | } | 2242 | } |
| 2212 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2243 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2213 | }, | 2244 | }, |
| 2214 | .anyframe_type => unreachable, | 2245 | .anyframe_type => unreachable, |
| 2215 | .error_union_type => |error_union_type| { | 2246 | .error_union_type => |error_union_type| { |
| ... | @@ -2226,49 +2257,49 @@ fn updateConstInner( | ... | @@ -2226,49 +2257,49 @@ fn updateConstInner( |
| 2226 | const name = try zcu.gpa.print("{f}", .{eu_ty.fmt(pt)}); | 2257 | const name = try zcu.gpa.print("{f}", .{eu_ty.fmt(pt)}); |
| 2227 | defer zcu.gpa.free(name); | 2258 | defer zcu.gpa.free(name); |
| 2228 | | 2259 | |
| 2229 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_union_type)); | 2260 | try dwarf.abbrevCode(di_nw, .generated_union_type); |
| 2230 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2261 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2231 | if (error_union_type.error_set_type != .generic_poison_type and | 2262 | if (error_union_type.error_set_type != .generic_poison_type and |
| 2232 | error_union_type.payload_type != .generic_poison_type) | 2263 | error_union_type.payload_type != .generic_poison_type) |
| 2233 | { | 2264 | { |
| 2234 | try diw.writeUleb128(eu_ty.abiSize(zcu)); | 2265 | try di_w.writeUleb128(eu_ty.abiSize(zcu)); |
| 2235 | try diw.writeUleb128(eu_ty.abiAlignment(zcu).toByteUnits().?); | 2266 | try di_w.writeUleb128(eu_ty.abiAlignment(zcu).toByteUnits().?); |
| 2236 | } else { | 2267 | } else { |
| 2237 | try diw.writeUleb128(0); | 2268 | try di_w.writeUleb128(0); |
| 2238 | try diw.writeUleb128(1); | 2269 | try di_w.writeUleb128(1); |
| 2239 | } | 2270 | } |
| 2240 | { | 2271 | { |
| 2241 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union)); | 2272 | try dwarf.abbrevCode(di_nw, .tagged_union); |
| 2242 | try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize()); | 2273 | try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize()); |
| 2243 | { | 2274 | { |
| 2244 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2275 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2245 | try dwarf.strp(&dwarf.debug_str, di_nw, "is_error"); | 2276 | try dwarf.strp(&dwarf.debug_str, di_nw, "is_error"); |
| 2246 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); | 2277 | 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); |
| 2248 | | 2279 | |
| 2249 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field)); | 2280 | try dwarf.abbrevCode(di_nw, .tagged_union_field); |
| 2250 | try diw.writeUleb128(DW.FORM.udata); | 2281 | try di_w.writeUleb128(DW.FORM.udata); |
| 2251 | try diw.writeUleb128(0); | 2282 | try di_w.writeUleb128(0); |
| 2252 | { | 2283 | { |
| 2253 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2284 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2254 | try dwarf.strp(&dwarf.debug_str, di_nw, "value"); | 2285 | try dwarf.strp(&dwarf.debug_str, di_nw, "value"); |
| 2255 | try dwarf.refType(pt, di_nw, eu_payload_ty); | 2286 | try dwarf.refType(pt, di_nw, eu_payload_ty); |
| 2256 | try diw.writeUleb128(eu_payload_offset); | 2287 | try di_w.writeUleb128(eu_payload_offset); |
| 2257 | } | 2288 | } |
| 2258 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2289 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2259 | | 2290 | |
| 2260 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_default_field)); | 2291 | try dwarf.abbrevCode(di_nw, .tagged_union_default_field); |
| 2261 | { | 2292 | { |
| 2262 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2293 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2263 | try dwarf.strp(&dwarf.debug_str, di_nw, "error"); | 2294 | try dwarf.strp(&dwarf.debug_str, di_nw, "error"); |
| 2264 | try dwarf.refType(pt, di_nw, eu_error_set_ty); | 2295 | 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); |
| 2266 | } | 2297 | } |
| 2267 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2298 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2268 | } | 2299 | } |
| 2269 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2300 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2270 | } | 2301 | } |
| 2271 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2302 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2272 | }, | 2303 | }, |
| 2273 | .simple_type => |simple_type| switch (simple_type) { | 2304 | .simple_type => |simple_type| switch (simple_type) { |
| 2274 | .f16, | 2305 | .f16, |
| ... | @@ -2291,9 +2322,9 @@ fn updateConstInner( | ... | @@ -2291,9 +2322,9 @@ fn updateConstInner( |
| 2291 | .bool, | 2322 | .bool, |
| 2292 | => { | 2323 | => { |
| 2293 | const ty: Type = .fromInterned(val); | 2324 | const ty: Type = .fromInterned(val); |
| 2294 | try diw.writeUleb128(try dwarf.refAbbrevCode(.numeric_type)); | 2325 | try dwarf.abbrevCode(di_nw, .numeric_type); |
| 2295 | try dwarf.strp(&dwarf.debug_str, di_nw, @tagName(simple_type)); | 2326 | 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) |
| 2297 | DW.ATE.boolean | 2328 | DW.ATE.boolean |
| 2298 | else if (ty.isRuntimeFloat()) | 2329 | else if (ty.isRuntimeFloat()) |
| 2299 | DW.ATE.float | 2330 | DW.ATE.float |
| ... | @@ -2303,12 +2334,12 @@ fn updateConstInner( | ... | @@ -2303,12 +2334,12 @@ fn updateConstInner( |
| 2303 | DW.ATE.unsigned | 2334 | DW.ATE.unsigned |
| 2304 | else | 2335 | else |
| 2305 | unreachable); | 2336 | unreachable); |
| 2306 | try diw.writeUleb128(ty.bitSize(zcu)); | 2337 | try di_w.writeUleb128(ty.bitSize(zcu)); |
| 2307 | try diw.writeUleb128(ty.abiSize(zcu)); | 2338 | try di_w.writeUleb128(ty.abiSize(zcu)); |
| 2308 | try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); | 2339 | try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); |
| 2309 | }, | 2340 | }, |
| 2310 | .generic_poison => { | 2341 | .generic_poison => { |
| 2311 | try diw.writeUleb128(try dwarf.refAbbrevCode(.void_type)); | 2342 | try dwarf.abbrevCode(di_nw, .void_type); |
| 2312 | try dwarf.strp(&dwarf.debug_str, di_nw, "anytype"); | 2343 | try dwarf.strp(&dwarf.debug_str, di_nw, "anytype"); |
| 2313 | }, | 2344 | }, |
| 2314 | .anyopaque, | 2345 | .anyopaque, |
| ... | @@ -2322,24 +2353,27 @@ fn updateConstInner( | ... | @@ -2322,24 +2353,27 @@ fn updateConstInner( |
| 2322 | .enum_literal, | 2353 | .enum_literal, |
| 2323 | => { | 2354 | => { |
| 2324 | const ty: Type = .fromInterned(val); | 2355 | const ty: Type = .fromInterned(val); |
| 2325 | try diw.writeUleb128(try dwarf.refAbbrevCode(.void_type)); | 2356 | try dwarf.abbrevCode(di_nw, .void_type); |
| 2326 | var name_buf: ["@TypeOf(undefined)".len]u8 = undefined; | 2357 | 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); |
| 2328 | }, | 2361 | }, |
| 2329 | .anyerror => { | 2362 | .anyerror => { |
| 2330 | const global_error_set_names = ip.global_error_set.getNamesFromMainThread(); | 2363 | const global_error_set_names = ip.global_error_set.getNamesFromMainThread(); |
| 2331 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2364 | try dwarf.abbrevCode(di_nw, if (global_error_set_names.len > 0) |
| 2332 | if (global_error_set_names.len > 0) .generated_enum_type else .generated_empty_enum_type, | 2365 | .generated_enum_type |
| 2333 | )); | 2366 | else |
| | 2367 | .generated_empty_enum_type); |
| 2334 | try dwarf.strp(&dwarf.debug_str, di_nw, "anyerror"); | 2368 | try dwarf.strp(&dwarf.debug_str, di_nw, "anyerror"); |
| 2335 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); | 2369 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); |
| 2336 | for (global_error_set_names, 1..) |name, value| { | 2370 | for (global_error_set_names, 1..) |name, value| { |
| 2337 | try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field)); | 2371 | try dwarf.abbrevCode(di_nw, .enum_field); |
| 2338 | try diw.writeUleb128(DW.FORM.udata); | 2372 | try di_w.writeUleb128(DW.FORM.udata); |
| 2339 | try diw.writeUleb128(value); | 2373 | try di_w.writeUleb128(value); |
| 2340 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); | 2374 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); |
| 2341 | } | 2375 | } |
| 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)); |
| 2343 | }, | 2377 | }, |
| 2344 | .adhoc_inferred_error_set => unreachable, | 2378 | .adhoc_inferred_error_set => unreachable, |
| 2345 | }, | 2379 | }, |
| ... | @@ -2348,14 +2382,14 @@ fn updateConstInner( | ... | @@ -2348,14 +2382,14 @@ fn updateConstInner( |
| 2348 | const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)}); | 2382 | const name = try zcu.gpa.print("{f}", .{ty.fmt(pt)}); |
| 2349 | defer zcu.gpa.free(name); | 2383 | defer zcu.gpa.free(name); |
| 2350 | if (tuple_type.types.len == 0) { | 2384 | 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); |
| 2352 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2386 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2353 | try diw.writeByte(@intFromBool(false)); | 2387 | try di_w.writeByte(@intFromBool(false)); |
| 2354 | } else { | 2388 | } else { |
| 2355 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_struct_type)); | 2389 | try dwarf.abbrevCode(di_nw, .generated_struct_type); |
| 2356 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2390 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2357 | try diw.writeUleb128(ty.abiSize(zcu)); | 2391 | try di_w.writeUleb128(ty.abiSize(zcu)); |
| 2358 | try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); | 2392 | try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); |
| 2359 | var field_byte_offset: u64 = 0; | 2393 | var field_byte_offset: u64 = 0; |
| 2360 | for (0..tuple_type.types.len) |field_index| { | 2394 | for (0..tuple_type.types.len) |field_index| { |
| 2361 | const comptime_value = tuple_type.values.get(ip)[field_index]; | 2395 | const comptime_value = tuple_type.values.get(ip)[field_index]; |
| ... | @@ -2364,7 +2398,7 @@ fn updateConstInner( | ... | @@ -2364,7 +2398,7 @@ fn updateConstInner( |
| 2364 | .none => .no_possible_value, | 2398 | .none => .no_possible_value, |
| 2365 | else => field_ty.classify(zcu), | 2399 | else => field_ty.classify(zcu), |
| 2366 | }; | 2400 | }; |
| 2367 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (comptime_value) { | 2401 | try dwarf.abbrevCode(di_nw, switch (comptime_value) { |
| 2368 | .none => .field, | 2402 | .none => .field, |
| 2369 | else => switch (comptime_value_class) { | 2403 | else => switch (comptime_value_class) { |
| 2370 | .no_possible_value, .one_possible_value => .field_comptime, | 2404 | .no_possible_value, .one_possible_value => .field_comptime, |
| ... | @@ -2372,19 +2406,17 @@ fn updateConstInner( | ... | @@ -2372,19 +2406,17 @@ fn updateConstInner( |
| 2372 | .partially_comptime => .field_comptime_partially_comptime, | 2406 | .partially_comptime => .field_comptime_partially_comptime, |
| 2373 | .fully_comptime => .field_comptime_fully_comptime, | 2407 | .fully_comptime => .field_comptime_fully_comptime, |
| 2374 | }, | 2408 | }, |
| 2375 | })); | 2409 | }); |
| 2376 | var field_name_buf: [std.fmt.count("{d}", .{std.math.maxInt(u32)})]u8 = undefined; | 2410 | var field_name_buf: [std.fmt.count("{d}", .{std.math.maxInt(u32)})]u8 = undefined; |
| 2377 | try dwarf.strp( | 2411 | try dwarf.strp(&dwarf.debug_str, di_nw, std.mem.print(&field_name_buf, "{d}", .{ |
| 2378 | &dwarf.debug_str, | 2412 | field_index, |
| 2379 | di_nw, | 2413 | }) catch unreachable); |
| 2380 | std.mem.print(&field_name_buf, "{d}", .{field_index}) catch unreachable, | | |
| 2381 | ); | | |
| 2382 | try dwarf.refType(pt, di_nw, field_ty); | 2414 | try dwarf.refType(pt, di_nw, field_ty); |
| 2383 | if (comptime_value == .none) { | 2415 | if (comptime_value == .none) { |
| 2384 | const field_align = field_ty.abiAlignment(zcu); | 2416 | const field_align = field_ty.abiAlignment(zcu); |
| 2385 | field_byte_offset = field_align.forward(field_byte_offset); | 2417 | field_byte_offset = field_align.forward(field_byte_offset); |
| 2386 | try diw.writeUleb128(field_byte_offset); | 2418 | try di_w.writeUleb128(field_byte_offset); |
| 2387 | try diw.writeUleb128(field_ty.abiAlignment(zcu).toByteUnits().?); | 2419 | try di_w.writeUleb128(field_ty.abiAlignment(zcu).toByteUnits().?); |
| 2388 | field_byte_offset += field_ty.abiSize(zcu); | 2420 | field_byte_offset += field_ty.abiSize(zcu); |
| 2389 | } | 2421 | } |
| 2390 | if (comptime_value_class.hasRuntimeBits()) | 2422 | if (comptime_value_class.hasRuntimeBits()) |
| ... | @@ -2392,7 +2424,7 @@ fn updateConstInner( | ... | @@ -2392,7 +2424,7 @@ fn updateConstInner( |
| 2392 | if (comptime_value_class.comptimeOnly()) | 2424 | if (comptime_value_class.comptimeOnly()) |
| 2393 | try dwarf.refConst(pt, di_nw, .fromInterned(comptime_value)); | 2425 | try dwarf.refConst(pt, di_nw, .fromInterned(comptime_value)); |
| 2394 | } | 2426 | } |
| 2395 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2427 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2396 | } | 2428 | } |
| 2397 | }, | 2429 | }, |
| 2398 | .struct_type => { | 2430 | .struct_type => { |
| ... | @@ -2404,22 +2436,21 @@ fn updateConstInner( | ... | @@ -2404,22 +2436,21 @@ fn updateConstInner( |
| 2404 | assert(loaded_struct.captures.len == 0); | 2436 | assert(loaded_struct.captures.len == 0); |
| 2405 | const ui = dwarf.getUnit(zf.mod.?); | 2437 | const ui = dwarf.getUnit(zf.mod.?); |
| 2406 | _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, zfi); | 2438 | _, 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) { |
| 2408 | .auto => if (loaded_struct.field_types.len > 0) .file else .empty_file, | 2440 | .auto => if (loaded_struct.field_types.len > 0) .file else .empty_file, |
| 2409 | .@"extern", .@"packed" => unreachable, | 2441 | .@"extern", .@"packed" => unreachable, |
| 2410 | })); | 2442 | }); |
| 2411 | try diw.writeUleb128(@backingInt(fi)); | 2443 | try di_w.writeUleb128(@backingInt(fi)); |
| 2412 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip)); | 2444 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip)); |
| 2413 | } else if (loaded_struct.captures.len > 0 or loaded_struct.is_reified) { | 2445 | } else if (loaded_struct.captures.len > 0 or loaded_struct.is_reified) { |
| 2414 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2446 | try dwarf.abbrevCode(di_nw, if (loaded_struct.captures.len > 0 or |
| 2415 | if (loaded_struct.captures.len > 0 or loaded_struct.field_types.len > 0) switch (loaded_struct.layout) { | 2447 | loaded_struct.field_types.len > 0) switch (loaded_struct.layout) { |
| 2416 | .auto, .@"extern" => .decl_instance_struct, | 2448 | .auto, .@"extern" => .decl_instance_struct, |
| 2417 | .@"packed" => .decl_instance_packed_struct, | 2449 | .@"packed" => .decl_instance_packed_struct, |
| 2418 | } else switch (loaded_struct.layout) { | 2450 | } else switch (loaded_struct.layout) { |
| 2419 | .auto, .@"extern" => .decl_instance_empty_struct, | 2451 | .auto, .@"extern" => .decl_instance_empty_struct, |
| 2420 | .@"packed" => .decl_instance_empty_packed_struct, | 2452 | .@"packed" => .decl_instance_empty_packed_struct, |
| 2421 | }, | 2453 | }); |
| 2422 | )); | | |
| 2423 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); | 2454 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); |
| 2424 | } else if (loaded_struct.name_nav.unwrap()) |name_ni| { | 2455 | } else if (loaded_struct.name_nav.unwrap()) |name_ni| { |
| 2425 | const name_nav = ip.getNav(name_ni); | 2456 | const name_nav = ip.getNav(name_ni); |
| ... | @@ -2427,34 +2458,44 @@ fn updateConstInner( | ... | @@ -2427,34 +2458,44 @@ fn updateConstInner( |
| 2427 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2458 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2428 | name_nav.analysis.?.namespace, | 2459 | name_nav.analysis.?.namespace, |
| 2429 | ).owner_type); | 2460 | ).owner_type); |
| 2430 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_struct.layout) { | 2461 | try dwarf.abbrevCode(di_nw, if (loaded_struct.field_types.len > 0) |
| 2431 | .auto, .@"extern" => if (loaded_struct.field_types.len > 0) .decl_struct else .decl_empty_struct, | 2462 | switch (loaded_struct.layout) { |
| 2432 | .@"packed" => if (loaded_struct.field_types.len > 0) .decl_packed_struct else .decl_empty_packed_struct, | 2463 | .auto, .@"extern" => .decl_struct, |
| 2433 | })); | 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 | }); |
| 2434 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2470 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2435 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2471 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2436 | try diw.writeUleb128(decl.src_column + 1); | 2472 | try di_w.writeUleb128(decl.src_column + 1); |
| 2437 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 2473 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 2438 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); | 2474 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); |
| 2439 | } else { | 2475 | } else { |
| 2440 | const decl = zf.zir.?.getStructDecl(src_inst.?); | 2476 | const decl = zf.zir.?.getStructDecl(src_inst.?); |
| 2441 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2477 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2442 | ip.namespacePtr(loaded_struct.namespace).parent.unwrap().?, | 2478 | ip.namespacePtr(loaded_struct.namespace).parent.unwrap().?, |
| 2443 | ).owner_type); | 2479 | ).owner_type); |
| 2444 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_struct.layout) { | 2480 | try dwarf.abbrevCode(di_nw, if (loaded_struct.field_types.len > 0) |
| 2445 | .auto, .@"extern" => if (loaded_struct.field_types.len > 0) .type_decl_struct else .type_decl_empty_struct, | 2481 | switch (loaded_struct.layout) { |
| 2446 | .@"packed" => if (loaded_struct.field_types.len > 0) .type_decl_packed_struct else .type_decl_empty_packed_struct, | 2482 | .auto, .@"extern" => .type_decl_struct, |
| 2447 | })); | 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 | }); |
| 2448 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2489 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2449 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2490 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2450 | try diw.writeUleb128(decl.src_column + 1); | 2491 | try di_w.writeUleb128(decl.src_column + 1); |
| 2451 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip)); | 2492 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip)); |
| 2452 | } | 2493 | } |
| 2453 | switch (loaded_struct.layout) { | 2494 | switch (loaded_struct.layout) { |
| 2454 | .auto, .@"extern" => { | 2495 | .auto, .@"extern" => { |
| 2455 | const ty: Type = .fromInterned(val); | 2496 | const ty: Type = .fromInterned(val); |
| 2456 | try diw.writeUleb128(ty.abiSize(zcu)); | 2497 | try di_w.writeUleb128(ty.abiSize(zcu)); |
| 2457 | try diw.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); | 2498 | try di_w.writeUleb128(ty.abiAlignment(zcu).toByteUnits().?); |
| 2458 | try dwarf.genCaptures(pt, di_nw, loaded_struct.captures); | 2499 | try dwarf.genCaptures(pt, di_nw, loaded_struct.captures); |
| 2459 | for (0..loaded_struct.field_types.len) |field_index| { | 2500 | for (0..loaded_struct.field_types.len) |field_index| { |
| 2460 | const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index); | 2501 | const is_comptime = loaded_struct.field_is_comptime_bits.get(ip, field_index); |
| ... | @@ -2466,26 +2507,40 @@ fn updateConstInner( | ... | @@ -2466,26 +2507,40 @@ fn updateConstInner( |
| 2466 | // indicate completion of the type's layout, a task should be enqueued | 2507 | // indicate completion of the type's layout, a task should be enqueued |
| 2467 | // by `Zcu.PerThread.ensureStructDefaultsUpToDate`, and upon receiving | 2508 | // by `Zcu.PerThread.ensureStructDefaultsUpToDate`, and upon receiving |
| 2468 | // it we should patch the correct default field values in. | 2509 | // it we should patch the correct default field values in. |
| 2469 | const field_default: InternPool.Index = | 2510 | const field_default = if (is_comptime) |
| 2470 | if (is_comptime) loaded_struct.field_defaults.getOrNone(ip, field_index) else .none; | 2511 | loaded_struct.field_defaults.getOrNone(ip, field_index) |
| | 2512 | else |
| | 2513 | .none; |
| 2471 | assert(!(is_comptime and field_default == .none)); | 2514 | 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]); |
| 2473 | const field_default_class = switch (field_default) { | 2517 | const field_default_class = switch (field_default) { |
| 2474 | .none => .no_possible_value, | 2518 | .none => .no_possible_value, |
| 2475 | else => field_ty.classify(zcu), | 2519 | else => field_ty.classify(zcu), |
| 2476 | }; | 2520 | }; |
| 2477 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (field_default_class) { | 2521 | try dwarf.abbrevCode(di_nw, if (is_comptime) switch (field_default_class) { |
| 2478 | .no_possible_value, .one_possible_value => if (is_comptime) .field_comptime else .field, | 2522 | .no_possible_value, .one_possible_value => .field_comptime, |
| 2479 | .runtime => if (is_comptime) .field_comptime_fully_runtime else .field_default_fully_runtime, | 2523 | .runtime => .field_comptime_fully_runtime, |
| 2480 | .partially_comptime => if (is_comptime) .field_comptime_partially_comptime else .field_default_partially_comptime, | 2524 | .partially_comptime => .field_comptime_partially_comptime, |
| 2481 | .fully_comptime => if (is_comptime) .field_comptime_fully_comptime else .field_default_fully_comptime, | 2525 | .fully_comptime => .field_comptime_fully_comptime, |
| 2482 | })); | 2526 | } else switch (field_default_class) { |
| 2483 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.field_names.get(ip)[field_index].toSlice(ip)); | 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 | ); |
| 2484 | try dwarf.refType(pt, di_nw, field_ty); | 2537 | try dwarf.refType(pt, di_nw, field_ty); |
| 2485 | if (!is_comptime) { | 2538 | if (!is_comptime) { |
| 2486 | try diw.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]); | 2539 | try di_w.writeUleb128(loaded_struct.field_offsets.get(ip)[field_index]); |
| 2487 | try diw.writeUleb128(loaded_struct.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse | 2540 | try di_w.writeUleb128(loaded_struct.field_aligns.getOrNone( |
| 2488 | field_ty.abiAlignment(zcu).toByteUnits().?); | 2541 | ip, |
| | 2542 | field_index, |
| | 2543 | ).toByteUnits() orelse field_ty.abiAlignment(zcu).toByteUnits().?); |
| 2489 | } | 2544 | } |
| 2490 | if (field_default_class.hasRuntimeBits()) | 2545 | if (field_default_class.hasRuntimeBits()) |
| 2491 | try dwarf.blockConst(pt, di_nw, .fromInterned(field_default)); | 2546 | try dwarf.blockConst(pt, di_nw, .fromInterned(field_default)); |
| ... | @@ -2498,17 +2553,22 @@ fn updateConstInner( | ... | @@ -2498,17 +2553,22 @@ fn updateConstInner( |
| 2498 | try dwarf.genCaptures(pt, di_nw, loaded_struct.captures); | 2553 | try dwarf.genCaptures(pt, di_nw, loaded_struct.captures); |
| 2499 | var field_bit_offset: u16 = 0; | 2554 | var field_bit_offset: u16 = 0; |
| 2500 | for (0..loaded_struct.field_types.len) |field_index| { | 2555 | for (0..loaded_struct.field_types.len) |field_index| { |
| 2501 | try diw.writeUleb128(try dwarf.refAbbrevCode(.packed_field)); | 2556 | try dwarf.abbrevCode(di_nw, .packed_field); |
| 2502 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.field_names.get(ip)[field_index].toSlice(ip)); | 2557 | try dwarf.strp( |
| 2503 | const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]); | 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]); |
| 2504 | try dwarf.refType(pt, di_nw, field_ty); | 2564 | try dwarf.refType(pt, di_nw, field_ty); |
| 2505 | try diw.writeUleb128(field_bit_offset); | 2565 | try di_w.writeUleb128(field_bit_offset); |
| 2506 | field_bit_offset += @intCast(field_ty.bitSize(zcu)); | 2566 | field_bit_offset += @intCast(field_ty.bitSize(zcu)); |
| 2507 | } | 2567 | } |
| 2508 | }, | 2568 | }, |
| 2509 | } | 2569 | } |
| 2510 | if (loaded_struct.captures.len > 0 or loaded_struct.field_types.len > 0) | 2570 | 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)); |
| 2512 | }, | 2572 | }, |
| 2513 | .union_type => { | 2573 | .union_type => { |
| 2514 | const loaded_union = ip.loadUnionType(val); | 2574 | const loaded_union = ip.loadUnionType(val); |
| ... | @@ -2516,15 +2576,14 @@ fn updateConstInner( | ... | @@ -2516,15 +2576,14 @@ fn updateConstInner( |
| 2516 | const zfi = loaded_union.zir_index.resolveFile(ip); | 2576 | const zfi = loaded_union.zir_index.resolveFile(ip); |
| 2517 | const zf = zcu.fileByIndex(zfi); | 2577 | const zf = zcu.fileByIndex(zfi); |
| 2518 | if (loaded_union.captures.len > 0 or loaded_union.is_reified) { | 2578 | if (loaded_union.captures.len > 0 or loaded_union.is_reified) { |
| 2519 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2579 | try dwarf.abbrevCode(di_nw, if (loaded_union.captures.len > 0 or |
| 2520 | if (loaded_union.captures.len > 0 or loaded_union.field_types.len > 0) switch (loaded_union.layout) { | 2580 | loaded_union.field_types.len > 0) switch (loaded_union.layout) { |
| 2521 | .auto, .@"extern" => .decl_instance_union, | 2581 | .auto, .@"extern" => .decl_instance_union, |
| 2522 | .@"packed" => .decl_instance_packed_union, | 2582 | .@"packed" => .decl_instance_packed_union, |
| 2523 | } else switch (loaded_union.layout) { | 2583 | } else switch (loaded_union.layout) { |
| 2524 | .auto, .@"extern" => .decl_instance_empty_union, | 2584 | .auto, .@"extern" => .decl_instance_empty_union, |
| 2525 | .@"packed" => .decl_instance_empty_packed_union, | 2585 | .@"packed" => .decl_instance_empty_packed_union, |
| 2526 | }, | 2586 | }); |
| 2527 | )); | | |
| 2528 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); | 2587 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); |
| 2529 | } else if (loaded_union.name_nav.unwrap()) |name_ni| { | 2588 | } else if (loaded_union.name_nav.unwrap()) |name_ni| { |
| 2530 | const name_nav = ip.getNav(name_ni); | 2589 | const name_nav = ip.getNav(name_ni); |
| ... | @@ -2532,86 +2591,118 @@ fn updateConstInner( | ... | @@ -2532,86 +2591,118 @@ fn updateConstInner( |
| 2532 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2591 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2533 | name_nav.analysis.?.namespace, | 2592 | name_nav.analysis.?.namespace, |
| 2534 | ).owner_type); | 2593 | ).owner_type); |
| 2535 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_union.layout) { | 2594 | try dwarf.abbrevCode(di_nw, if (loaded_union.field_types.len > 0) |
| 2536 | .auto, .@"extern" => if (loaded_union.field_types.len > 0) .decl_union else .decl_empty_union, | 2595 | switch (loaded_union.layout) { |
| 2537 | .@"packed" => if (loaded_union.field_types.len > 0) .decl_packed_union else .decl_empty_packed_union, | 2596 | .auto, .@"extern" => .decl_union, |
| 2538 | })); | 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 | }); |
| 2539 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2603 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2540 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2604 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2541 | try diw.writeUleb128(decl.src_column + 1); | 2605 | try di_w.writeUleb128(decl.src_column + 1); |
| 2542 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 2606 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 2543 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); | 2607 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); |
| 2544 | } else { | 2608 | } else { |
| 2545 | const decl = zf.zir.?.getUnionDecl(loaded_union.zir_index.resolve(ip).?); | 2609 | const decl = zf.zir.?.getUnionDecl(loaded_union.zir_index.resolve(ip).?); |
| 2546 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2610 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2547 | ip.namespacePtr(loaded_union.namespace).parent.unwrap().?, | 2611 | ip.namespacePtr(loaded_union.namespace).parent.unwrap().?, |
| 2548 | ).owner_type); | 2612 | ).owner_type); |
| 2549 | try diw.writeUleb128(try dwarf.refAbbrevCode(switch (loaded_union.layout) { | 2613 | try dwarf.abbrevCode(di_nw, if (loaded_union.field_types.len > 0) |
| 2550 | .auto, .@"extern" => if (loaded_union.field_types.len > 0) .type_decl_union else .type_decl_empty_union, | 2614 | switch (loaded_union.layout) { |
| 2551 | .@"packed" => if (loaded_union.field_types.len > 0) .type_decl_packed_union else .type_decl_empty_packed_union, | 2615 | .auto, .@"extern" => .type_decl_union, |
| 2552 | })); | 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 | }); |
| 2553 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2622 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2554 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2623 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2555 | try diw.writeUleb128(decl.src_column + 1); | 2624 | try di_w.writeUleb128(decl.src_column + 1); |
| 2556 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_union.name.toSlice(ip)); | 2625 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_union.name.toSlice(ip)); |
| 2557 | } | 2626 | } |
| 2558 | switch (loaded_union.layout) { | 2627 | switch (loaded_union.layout) { |
| 2559 | .auto, .@"extern" => { | 2628 | .auto, .@"extern" => { |
| 2560 | const union_layout = Type.getUnionLayout(loaded_union, zcu); | 2629 | const union_layout = Type.getUnionLayout(loaded_union, zcu); |
| 2561 | try diw.writeUleb128(union_layout.abi_size); | 2630 | try di_w.writeUleb128(union_layout.abi_size); |
| 2562 | try diw.writeUleb128(union_layout.abi_align.toByteUnits().?); | 2631 | try di_w.writeUleb128(union_layout.abi_align.toByteUnits().?); |
| 2563 | try dwarf.genCaptures(pt, di_nw, loaded_union.captures); | 2632 | try dwarf.genCaptures(pt, di_nw, loaded_union.captures); |
| 2564 | if (loaded_union.has_runtime_tag) { | 2633 | if (loaded_union.has_runtime_tag) { |
| 2565 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union)); | 2634 | try dwarf.abbrevCode(di_nw, .tagged_union); |
| 2566 | try dwarf.secOffset(di_nw, di_nw.ni, diw.end + dwarf.secOffsetSize()); | 2635 | try dwarf.secOffset(di_nw, di_nw.ni, di_w.end + dwarf.secOffsetSize()); |
| 2567 | { | 2636 | { |
| 2568 | try diw.writeUleb128(try dwarf.refAbbrevCode(.generated_field)); | 2637 | try dwarf.abbrevCode(di_nw, .generated_field); |
| 2569 | try dwarf.strp(&dwarf.debug_str, di_nw, "tag"); | 2638 | try dwarf.strp(&dwarf.debug_str, di_nw, "tag"); |
| 2570 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.enum_tag_type)); | 2639 | 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()); |
| 2572 | | 2641 | |
| 2573 | for (0..loaded_union.field_types.len) |field_index| { | 2642 | for (0..loaded_union.field_types.len) |field_index| { |
| 2574 | try diw.writeUleb128(try dwarf.refAbbrevCode(.tagged_union_field)); | 2643 | try dwarf.abbrevCode(di_nw, .tagged_union_field); |
| 2575 | try dwarf.enumConstValue(diw, loaded_tag, field_index); | 2644 | try dwarf.enumConstValue(di_w, loaded_tag, field_index); |
| 2576 | { | 2645 | { |
| 2577 | try diw.writeUleb128(try dwarf.refAbbrevCode(.field)); | 2646 | try dwarf.abbrevCode(di_nw, .field); |
| 2578 | try dwarf.strp( | 2647 | try dwarf.strp( |
| 2579 | &dwarf.debug_str, | 2648 | &dwarf.debug_str, |
| 2580 | di_nw, | 2649 | di_nw, |
| 2581 | loaded_tag.field_names.get(ip)[field_index].toSlice(ip), | 2650 | loaded_tag.field_names.get(ip)[field_index].toSlice(ip), |
| 2582 | ); | 2651 | ); |
| 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]); |
| 2584 | try dwarf.refType(pt, di_nw, field_ty); | 2654 | try dwarf.refType(pt, di_nw, field_ty); |
| 2585 | try diw.writeUleb128(union_layout.payloadOffset()); | 2655 | try di_w.writeUleb128(union_layout.payloadOffset()); |
| 2586 | try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse | 2656 | try di_w.writeUleb128(loaded_union.field_aligns.getOrNone( |
| 2587 | if (field_ty.isNoReturn(zcu)) 1 else field_ty.abiAlignment(zcu).toByteUnits().?); | 2657 | ip, |
| | 2658 | field_index, |
| | 2659 | ).toByteUnits() orelse if (field_ty.isNoReturn(zcu)) |
| | 2660 | 1 |
| | 2661 | else |
| | 2662 | field_ty.abiAlignment(zcu).toByteUnits().?); |
| 2588 | } | 2663 | } |
| 2589 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2664 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2590 | } | 2665 | } |
| 2591 | } | 2666 | } |
| 2592 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2667 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2593 | } else for (0..loaded_union.field_types.len) |field_index| { | 2668 | } else for (0..loaded_union.field_types.len) |field_index| { |
| 2594 | try diw.writeUleb128(try dwarf.refAbbrevCode(.field)); | 2669 | try dwarf.abbrevCode(di_nw, .field); |
| 2595 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_tag.field_names.get(ip)[field_index].toSlice(ip)); | 2670 | try dwarf.strp( |
| 2596 | const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]); | 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]); |
| 2597 | try dwarf.refType(pt, di_nw, field_ty); | 2677 | try dwarf.refType(pt, di_nw, field_ty); |
| 2598 | try diw.writeUleb128(0); | 2678 | try di_w.writeUleb128(0); |
| 2599 | try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse | 2679 | try di_w.writeUleb128(loaded_union.field_aligns.getOrNone( |
| 2600 | if (field_ty.isNoReturn(zcu)) 1 else field_ty.abiAlignment(zcu).toByteUnits().?); | 2680 | ip, |
| | 2681 | field_index, |
| | 2682 | ).toByteUnits() orelse if (field_ty.isNoReturn(zcu)) |
| | 2683 | 1 |
| | 2684 | else |
| | 2685 | field_ty.abiAlignment(zcu).toByteUnits().?); |
| 2601 | } | 2686 | } |
| 2602 | }, | 2687 | }, |
| 2603 | .@"packed" => { | 2688 | .@"packed" => { |
| 2604 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.packed_backing_int_type)); | 2689 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.packed_backing_int_type)); |
| 2605 | for (0..loaded_union.field_types.len) |field_index| { | 2690 | for (0..loaded_union.field_types.len) |field_index| { |
| 2606 | try diw.writeUleb128(try dwarf.refAbbrevCode(.packed_field)); | 2691 | try dwarf.abbrevCode(di_nw, .packed_field); |
| 2607 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_tag.field_names.get(ip)[field_index].toSlice(ip)); | 2692 | try dwarf.strp( |
| 2608 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_union.field_types.get(ip)[field_index])); | 2693 | &dwarf.debug_str, |
| 2609 | try diw.writeUleb128(0); | 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); |
| 2610 | } | 2701 | } |
| 2611 | }, | 2702 | }, |
| 2612 | } | 2703 | } |
| 2613 | if (loaded_union.captures.len > 0 or loaded_union.field_types.len > 0) | 2704 | 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)); |
| 2615 | }, | 2706 | }, |
| 2616 | .enum_type => { | 2707 | .enum_type => { |
| 2617 | const loaded_enum = ip.loadEnumType(val); | 2708 | const loaded_enum = ip.loadEnumType(val); |
| ... | @@ -2620,12 +2711,11 @@ fn updateConstInner( | ... | @@ -2620,12 +2711,11 @@ fn updateConstInner( |
| 2620 | const zfi = loaded_enum.zir_index.unwrap().?.resolveFile(ip); | 2711 | const zfi = loaded_enum.zir_index.unwrap().?.resolveFile(ip); |
| 2621 | const zf = zcu.fileByIndex(zfi); | 2712 | const zf = zcu.fileByIndex(zfi); |
| 2622 | if (loaded_enum.captures.len > 0 or loaded_enum.is_reified) { | 2713 | if (loaded_enum.captures.len > 0 or loaded_enum.is_reified) { |
| 2623 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2714 | try dwarf.abbrevCode(di_nw, if (loaded_enum.captures.len > 0 or |
| 2624 | if (loaded_enum.captures.len > 0 or loaded_enum.field_names.len > 0) | 2715 | loaded_enum.field_names.len > 0) |
| 2625 | .decl_instance_enum | 2716 | .decl_instance_enum |
| 2626 | else | 2717 | else |
| 2627 | .decl_instance_empty_enum, | 2718 | .decl_instance_empty_enum); |
| 2628 | )); | | |
| 2629 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); | 2719 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); |
| 2630 | } else if (loaded_enum.name_nav.unwrap()) |name_ni| { | 2720 | } else if (loaded_enum.name_nav.unwrap()) |name_ni| { |
| 2631 | const name_nav = ip.getNav(name_ni); | 2721 | const name_nav = ip.getNav(name_ni); |
| ... | @@ -2633,43 +2723,51 @@ fn updateConstInner( | ... | @@ -2633,43 +2723,51 @@ fn updateConstInner( |
| 2633 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2723 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2634 | name_nav.analysis.?.namespace, | 2724 | name_nav.analysis.?.namespace, |
| 2635 | ).owner_type); | 2725 | ).owner_type); |
| 2636 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2726 | try dwarf.abbrevCode( |
| | 2727 | di_nw, |
| 2637 | if (loaded_enum.field_names.len > 0) .decl_enum else .decl_empty_enum, | 2728 | if (loaded_enum.field_names.len > 0) .decl_enum else .decl_empty_enum, |
| 2638 | )); | 2729 | ); |
| 2639 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2730 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2640 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2731 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2641 | try diw.writeUleb128(decl.src_column + 1); | 2732 | try di_w.writeUleb128(decl.src_column + 1); |
| 2642 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 2733 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 2643 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); | 2734 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); |
| 2644 | } else { | 2735 | } 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).?); |
| 2646 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 2738 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 2647 | ip.namespacePtr(loaded_enum.namespace).parent.unwrap().?, | 2739 | ip.namespacePtr(loaded_enum.namespace).parent.unwrap().?, |
| 2648 | ).owner_type); | 2740 | ).owner_type); |
| 2649 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2741 | try dwarf.abbrevCode(di_nw, if (loaded_enum.field_names.len > 0) |
| 2650 | if (loaded_enum.field_names.len > 0) .type_decl_enum else .type_decl_empty_enum, | 2742 | .type_decl_enum |
| 2651 | )); | 2743 | else |
| | 2744 | .type_decl_empty_enum); |
| 2652 | try dwarf.secOffset(di_nw, parent_ni, 0); | 2745 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 2653 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2746 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2654 | try diw.writeUleb128(decl.src_column + 1); | 2747 | try di_w.writeUleb128(decl.src_column + 1); |
| 2655 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.name.toSlice(ip)); | 2748 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.name.toSlice(ip)); |
| 2656 | } | 2749 | } |
| 2657 | }, | 2750 | }, |
| 2658 | else => { | 2751 | else => { |
| 2659 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2752 | try dwarf.abbrevCode(di_nw, if (loaded_enum.field_names.len > 0) |
| 2660 | if (loaded_enum.field_names.len > 0) .generated_enum_type else .generated_empty_enum_type, | 2753 | .generated_enum_type |
| 2661 | )); | 2754 | else |
| | 2755 | .generated_empty_enum_type); |
| 2662 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.fqn.toSlice(ip)); | 2756 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.fqn.toSlice(ip)); |
| 2663 | }, | 2757 | }, |
| 2664 | } | 2758 | } |
| 2665 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_enum.int_tag_type)); | 2759 | try dwarf.refType(pt, di_nw, .fromInterned(loaded_enum.int_tag_type)); |
| 2666 | for (0..loaded_enum.field_names.len) |field_index| { | 2760 | for (0..loaded_enum.field_names.len) |field_index| { |
| 2667 | try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field)); | 2761 | try dwarf.abbrevCode(di_nw, .enum_field); |
| 2668 | try dwarf.enumConstValue(diw, loaded_enum, field_index); | 2762 | try dwarf.enumConstValue(di_w, loaded_enum, field_index); |
| 2669 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.field_names.get(ip)[field_index].toSlice(ip)); | 2763 | try dwarf.strp( |
| | 2764 | &dwarf.debug_str, |
| | 2765 | di_nw, |
| | 2766 | loaded_enum.field_names.get(ip)[field_index].toSlice(ip), |
| | 2767 | ); |
| 2670 | } | 2768 | } |
| 2671 | if (loaded_enum.captures.len > 0 or loaded_enum.field_names.len > 0) | 2769 | 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)); |
| 2673 | }, | 2771 | }, |
| 2674 | // no defined size, so lowered the same as incomplete struct types | 2772 | // no defined size, so lowered the same as incomplete struct types |
| 2675 | .opaque_type => return dwarf.updateConstIncompleteInner(pt, di_nw, val), | 2773 | .opaque_type => return dwarf.updateConstIncompleteInner(pt, di_nw, val), |
| ... | @@ -2678,9 +2776,7 @@ fn updateConstInner( | ... | @@ -2678,9 +2776,7 @@ fn updateConstInner( |
| 2678 | const is_nullary = func_type.param_types.len == 0 and !func_type.is_var_args; | 2776 | const is_nullary = func_type.param_types.len == 0 and !func_type.is_var_args; |
| 2679 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2777 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2680 | defer zcu.gpa.free(name); | 2778 | defer zcu.gpa.free(name); |
| 2681 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2779 | try dwarf.abbrevCode(di_nw, if (is_nullary) .nullary_func_type else .func_type); |
| 2682 | if (is_nullary) .nullary_func_type else .func_type, | | |
| 2683 | )); | | |
| 2684 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2780 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2685 | const cc: DW.CC = cc: { | 2781 | const cc: DW.CC = cc: { |
| 2686 | if (zcu.getTarget().cCallingConvention()) |cc| { | 2782 | if (zcu.getTarget().cCallingConvention()) |cc| { |
| ... | @@ -2751,38 +2847,41 @@ fn updateConstInner( | ... | @@ -2751,38 +2847,41 @@ fn updateConstInner( |
| 2751 | else => .nocall, | 2847 | else => .nocall, |
| 2752 | }; | 2848 | }; |
| 2753 | }; | 2849 | }; |
| 2754 | try diw.writeByte(@backingInt(cc)); | 2850 | try di_w.writeByte(@backingInt(cc)); |
| 2755 | try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type)); | 2851 | try dwarf.refType(pt, di_nw, .fromInterned(func_type.return_type)); |
| 2756 | if (!is_nullary) { | 2852 | if (!is_nullary) { |
| 2757 | for (0..func_type.param_types.len) |param_index| { | 2853 | for (0..func_type.param_types.len) |param_index| { |
| 2758 | try diw.writeUleb128(try dwarf.refAbbrevCode(.unnamed_param)); | 2854 | try dwarf.abbrevCode(di_nw, .unnamed_param); |
| 2759 | try dwarf.refType(pt, di_nw, .fromInterned(func_type.param_types.get(ip)[param_index])); | 2855 | try dwarf.refType(pt, di_nw, .fromInterned( |
| | 2856 | func_type.param_types.get(ip)[param_index], |
| | 2857 | )); |
| 2760 | } | 2858 | } |
| 2761 | if (func_type.is_var_args) try diw.writeUleb128(try dwarf.refAbbrevCode(.is_var_args)); | 2859 | if (func_type.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args); |
| 2762 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2860 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2763 | } | 2861 | } |
| 2764 | }, | 2862 | }, |
| 2765 | .error_set_type => |error_set_type| { | 2863 | .error_set_type => |error_set_type| { |
| 2766 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2864 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2767 | defer zcu.gpa.free(name); | 2865 | defer zcu.gpa.free(name); |
| 2768 | try diw.writeUleb128(try dwarf.refAbbrevCode( | 2866 | try dwarf.abbrevCode( |
| | 2867 | di_nw, |
| 2769 | if (error_set_type.names.len > 0) .generated_enum_type else .generated_empty_enum_type, | 2868 | if (error_set_type.names.len > 0) .generated_enum_type else .generated_empty_enum_type, |
| 2770 | )); | 2869 | ); |
| 2771 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2870 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2772 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); | 2871 | try dwarf.refType(pt, di_nw, try pt.intType(.unsigned, zcu.errorSetBits())); |
| 2773 | for (0..error_set_type.names.len) |field_index| { | 2872 | for (0..error_set_type.names.len) |field_index| { |
| 2774 | const field_name = error_set_type.names.get(ip)[field_index]; | 2873 | const field_name = error_set_type.names.get(ip)[field_index]; |
| 2775 | try diw.writeUleb128(try dwarf.refAbbrevCode(.enum_field)); | 2874 | try dwarf.abbrevCode(di_nw, .enum_field); |
| 2776 | try diw.writeUleb128(DW.FORM.udata); | 2875 | try di_w.writeUleb128(DW.FORM.udata); |
| 2777 | try diw.writeUleb128(ip.getErrorValueIfExists(field_name).?); | 2876 | try di_w.writeUleb128(ip.getErrorValueIfExists(field_name).?); |
| 2778 | try dwarf.strp(&dwarf.debug_str, di_nw, field_name.toSlice(ip)); | 2877 | try dwarf.strp(&dwarf.debug_str, di_nw, field_name.toSlice(ip)); |
| 2779 | } | 2878 | } |
| 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)); |
| 2781 | }, | 2880 | }, |
| 2782 | .inferred_error_set_type => |func| { | 2881 | .inferred_error_set_type => |func| { |
| 2783 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 2882 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 2784 | defer zcu.gpa.free(name); | 2883 | 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); |
| 2786 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 2885 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 2787 | try dwarf.refType(pt, di_nw, switch (ies: { | 2886 | try dwarf.refType(pt, di_nw, switch (ies: { |
| 2788 | const fi = dwarf.getFuncIfExists(ip.indexToKey(func).func.owner_nav) orelse | 2887 | const fi = dwarf.getFuncIfExists(ip.indexToKey(func).func.owner_nav) orelse |
| ... | @@ -2810,32 +2909,36 @@ fn updateConstInner( | ... | @@ -2810,32 +2909,36 @@ fn updateConstInner( |
| 2810 | const zf = zcu.fileByIndex(inst_info.file); | 2909 | const zf = zcu.fileByIndex(inst_info.file); |
| 2811 | const decl = zf.zir.?.getDeclaration(inst_info.inst); | 2910 | const decl = zf.zir.?.getDeclaration(inst_info.inst); |
| 2812 | const parent_ty: Type = .fromInterned(ip.namespacePtr(nav.analysis.?.namespace).owner_type); | 2911 | 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); |
| 2814 | try dwarf.refType(pt, di_nw, parent_ty); | 2913 | try dwarf.refType(pt, di_nw, parent_ty); |
| 2815 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 2914 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 2816 | try diw.writeUleb128(decl.src_column + 1); | 2915 | try di_w.writeUleb128(decl.src_column + 1); |
| 2817 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 2916 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 2818 | try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); | 2917 | try dwarf.strp(&dwarf.debug_str, di_nw, nav.name.toSlice(ip)); |
| 2819 | try dwarf.refType(pt, di_nw, .fromInterned(fn_ty.return_type)); | 2918 | try dwarf.refType(pt, di_nw, .fromInterned(fn_ty.return_type)); |
| 2820 | var param_index: u32 = 0; | 2919 | var param_index: u32 = 0; |
| 2821 | for (zf.zir.?.getParamBody(func.zir_body_inst.resolve(ip).?)) |param_inst| { | 2920 | for (zf.zir.?.getParamBody(func.zir_body_inst.resolve(ip).?)) |param_inst| { |
| 2822 | switch (zf.zir.?.getParamName(param_inst) orelse break) { | 2921 | 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), |
| 2824 | else => |param_name| { | 2923 | else => |param_name| { |
| 2825 | try diw.writeUleb128(try dwarf.refAbbrevCode(.param)); | 2924 | try dwarf.abbrevCode(di_nw, .param); |
| 2826 | try dwarf.strp(&dwarf.debug_str, di_nw, zf.zir.?.nullTerminatedString(param_name)); | 2925 | try dwarf.strp(&dwarf.debug_str, di_nw, zf.zir.?.nullTerminatedString( |
| | 2926 | param_name, |
| | 2927 | )); |
| 2827 | }, | 2928 | }, |
| 2828 | } | 2929 | } |
| 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 | )); |
| 2830 | param_index += 1; | 2933 | param_index += 1; |
| 2831 | } | 2934 | } |
| 2832 | if (fn_ty.is_var_args) try diw.writeUleb128(try dwarf.refAbbrevCode(.is_var_args)); | 2935 | if (fn_ty.is_var_args) try dwarf.abbrevCode(di_nw, .is_var_args); |
| 2833 | try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 2936 | try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 2834 | }, | 2937 | }, |
| 2835 | | 2938 | |
| 2836 | .memoized_call => unreachable, // not a value | 2939 | .memoized_call => unreachable, // not a value |
| 2837 | } | 2940 | } |
| 2838 | try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen()); | 2941 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); |
| 2839 | } | 2942 | } |
| 2840 | | 2943 | |
| 2841 | fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } { | 2944 | fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum { unpacked, opv_null, error_set, pointer } { |
| ... | @@ -2870,13 +2973,13 @@ fn updateConstIncompleteInner( | ... | @@ -2870,13 +2973,13 @@ fn updateConstIncompleteInner( |
| 2870 | ) link.EmitError!void { | 2973 | ) link.EmitError!void { |
| 2871 | const zcu = pt.zcu; | 2974 | const zcu = pt.zcu; |
| 2872 | const ip = &zcu.intern_pool; | 2975 | const ip = &zcu.intern_pool; |
| 2873 | const diw = &di_nw.interface; | 2976 | const di_w = &di_nw.interface; |
| 2874 | done: { | 2977 | done: { |
| 2875 | 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)) { | 2978 | 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)) { |
| 2876 | .struct_type => { | 2979 | .struct_type => { |
| 2877 | const loaded_struct = ip.loadStructType(val); | 2980 | const loaded_struct = ip.loadStructType(val); |
| 2878 | const src_inst = loaded_struct.zir_index.resolveFull(ip) orelse { | 2981 | 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); |
| 2880 | break :done; | 2983 | break :done; |
| 2881 | }; | 2984 | }; |
| 2882 | const zf = zcu.fileByIndex(src_inst.file); | 2985 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -2884,14 +2987,15 @@ fn updateConstIncompleteInner( | ... | @@ -2884,14 +2987,15 @@ fn updateConstIncompleteInner( |
| 2884 | .main_struct_inst => { | 2987 | .main_struct_inst => { |
| 2885 | const ui = dwarf.getUnit(zf.mod.?); | 2988 | const ui = dwarf.getUnit(zf.mod.?); |
| 2886 | _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, src_inst.file); | 2989 | _, const fi = try ui.get(dwarf).getFile(zcu.gpa, ui, src_inst.file); |
| 2887 | try diw.writeUleb128(try dwarf.refAbbrevCode(.empty_file)); | 2990 | try dwarf.abbrevCode(di_nw, .empty_file); |
| 2888 | try diw.writeUleb128(@backingInt(fi)); | 2991 | try di_w.writeUleb128(@backingInt(fi)); |
| 2889 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_struct.name.toSlice(ip)); | 2992 | 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)); |
| 2891 | break :done; | 2994 | break :done; |
| 2892 | }, | 2995 | }, |
| 2893 | else => { | 2996 | 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; |
| 2895 | const src_line, const src_column = src_loc: switch (data.opcode) { | 2999 | const src_line, const src_column = src_loc: switch (data.opcode) { |
| 2896 | else => unreachable, | 3000 | else => unreachable, |
| 2897 | .struct_decl => { | 3001 | .struct_decl => { |
| ... | @@ -2899,7 +3003,10 @@ fn updateConstIncompleteInner( | ... | @@ -2899,7 +3003,10 @@ fn updateConstIncompleteInner( |
| 2899 | break :src_loc .{ decl.src_line, decl.src_column }; | 3003 | break :src_loc .{ decl.src_line, decl.src_column }; |
| 2900 | }, | 3004 | }, |
| 2901 | .reify_struct => { | 3005 | .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; |
| 2903 | break :src_loc .{ decl.src_line, decl.src_column }; | 3010 | break :src_loc .{ decl.src_line, decl.src_column }; |
| 2904 | }, | 3011 | }, |
| 2905 | }; | 3012 | }; |
| ... | @@ -2920,7 +3027,7 @@ fn updateConstIncompleteInner( | ... | @@ -2920,7 +3027,7 @@ fn updateConstIncompleteInner( |
| 2920 | .union_type => { | 3027 | .union_type => { |
| 2921 | const loaded_union = ip.loadUnionType(val); | 3028 | const loaded_union = ip.loadUnionType(val); |
| 2922 | const src_inst = loaded_union.zir_index.resolveFull(ip) orelse { | 3029 | 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); |
| 2924 | break :done; | 3031 | break :done; |
| 2925 | }; | 3032 | }; |
| 2926 | const zf = zcu.fileByIndex(src_inst.file); | 3033 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -2951,13 +3058,13 @@ fn updateConstIncompleteInner( | ... | @@ -2951,13 +3058,13 @@ fn updateConstIncompleteInner( |
| 2951 | .enum_type => { | 3058 | .enum_type => { |
| 2952 | const loaded_enum = ip.loadEnumType(val); | 3059 | const loaded_enum = ip.loadEnumType(val); |
| 2953 | const zir_index = loaded_enum.zir_index.unwrap() orelse { | 3060 | 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); |
| 2955 | try dwarf.strp(&dwarf.debug_str, di_nw, loaded_enum.name.toSlice(ip)); | 3062 | 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)); |
| 2957 | break :done; | 3064 | break :done; |
| 2958 | }; | 3065 | }; |
| 2959 | const src_inst = zir_index.resolveFull(ip) orelse { | 3066 | const src_inst = zir_index.resolveFull(ip) orelse { |
| 2960 | try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost)); | 3067 | try dwarf.lostTracking(di_nw); |
| 2961 | break :done; | 3068 | break :done; |
| 2962 | }; | 3069 | }; |
| 2963 | const zf = zcu.fileByIndex(src_inst.file); | 3070 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -2989,7 +3096,7 @@ fn updateConstIncompleteInner( | ... | @@ -2989,7 +3096,7 @@ fn updateConstIncompleteInner( |
| 2989 | .opaque_type => { | 3096 | .opaque_type => { |
| 2990 | const loaded_opaque = ip.loadOpaqueType(val); | 3097 | const loaded_opaque = ip.loadOpaqueType(val); |
| 2991 | const src_inst = loaded_opaque.zir_index.resolveFull(ip) orelse { | 3098 | 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); |
| 2993 | break :done; | 3100 | break :done; |
| 2994 | }; | 3101 | }; |
| 2995 | const zf = zcu.fileByIndex(src_inst.file); | 3102 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -3010,18 +3117,18 @@ fn updateConstIncompleteInner( | ... | @@ -3010,18 +3117,18 @@ fn updateConstIncompleteInner( |
| 3010 | .type_type => { | 3117 | .type_type => { |
| 3011 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); | 3118 | const name = try zcu.gpa.print("{f}", .{Type.fromInterned(val).fmt(pt)}); |
| 3012 | defer zcu.gpa.free(name); | 3119 | 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); |
| 3014 | try dwarf.strp(&dwarf.debug_str, di_nw, name); | 3121 | try dwarf.strp(&dwarf.debug_str, di_nw, name); |
| 3015 | try diw.writeByte(@intFromBool(true)); | 3122 | try di_w.writeByte(@intFromBool(true)); |
| 3016 | }, | 3123 | }, |
| 3017 | else => |ty| { | 3124 | else => |ty| { |
| 3018 | try diw.writeUleb128(try dwarf.refAbbrevCode(.undefined_comptime_value)); | 3125 | try dwarf.abbrevCode(di_nw, .undefined_comptime_value); |
| 3019 | try dwarf.refType(pt, di_nw, .fromInterned(ty)); | 3126 | try dwarf.refType(pt, di_nw, .fromInterned(ty)); |
| 3020 | }, | 3127 | }, |
| 3021 | }, | 3128 | }, |
| 3022 | }; | 3129 | }; |
| 3023 | if (captures.len > 0 or is_reified) { | 3130 | 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) { |
| 3025 | .@"struct" => .decl_instance_incomplete_struct, | 3132 | .@"struct" => .decl_instance_incomplete_struct, |
| 3026 | .@"union" => .decl_instance_incomplete_union, | 3133 | .@"union" => .decl_instance_incomplete_union, |
| 3027 | .@"enum" => .decl_instance_incomplete_enum, | 3134 | .@"enum" => .decl_instance_incomplete_enum, |
| ... | @@ -3029,7 +3136,7 @@ fn updateConstIncompleteInner( | ... | @@ -3029,7 +3136,7 @@ fn updateConstIncompleteInner( |
| 3029 | .@"struct" => .decl_instance_empty_incomplete_struct, | 3136 | .@"struct" => .decl_instance_empty_incomplete_struct, |
| 3030 | .@"union" => .decl_instance_empty_incomplete_union, | 3137 | .@"union" => .decl_instance_empty_incomplete_union, |
| 3031 | .@"enum" => .decl_instance_empty_incomplete_enum, | 3138 | .@"enum" => .decl_instance_empty_incomplete_enum, |
| 3032 | })); | 3139 | }); |
| 3033 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); | 3140 | try dwarf.secOffset(di_nw, try dwarf.getDecl(pt, val), 0); |
| 3034 | } else if (maybe_name_nav.unwrap()) |name_ni| { | 3141 | } else if (maybe_name_nav.unwrap()) |name_ni| { |
| 3035 | const name_nav = ip.getNav(name_ni); | 3142 | const name_nav = ip.getNav(name_ni); |
| ... | @@ -3037,7 +3144,7 @@ fn updateConstIncompleteInner( | ... | @@ -3037,7 +3144,7 @@ fn updateConstIncompleteInner( |
| 3037 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 3144 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 3038 | name_nav.analysis.?.namespace, | 3145 | name_nav.analysis.?.namespace, |
| 3039 | ).owner_type); | 3146 | ).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) { |
| 3041 | .@"struct" => .decl_incomplete_struct, | 3148 | .@"struct" => .decl_incomplete_struct, |
| 3042 | .@"union" => .decl_incomplete_union, | 3149 | .@"union" => .decl_incomplete_union, |
| 3043 | .@"enum" => .decl_incomplete_enum, | 3150 | .@"enum" => .decl_incomplete_enum, |
| ... | @@ -3045,17 +3152,17 @@ fn updateConstIncompleteInner( | ... | @@ -3045,17 +3152,17 @@ fn updateConstIncompleteInner( |
| 3045 | .@"struct" => .decl_empty_incomplete_struct, | 3152 | .@"struct" => .decl_empty_incomplete_struct, |
| 3046 | .@"union" => .decl_empty_incomplete_union, | 3153 | .@"union" => .decl_empty_incomplete_union, |
| 3047 | .@"enum" => .decl_empty_incomplete_enum, | 3154 | .@"enum" => .decl_empty_incomplete_enum, |
| 3048 | })); | 3155 | }); |
| 3049 | try dwarf.secOffset(di_nw, parent_ni, 0); | 3156 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 3050 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 3157 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 3051 | try diw.writeUleb128(decl.src_column + 1); | 3158 | try di_w.writeUleb128(decl.src_column + 1); |
| 3052 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 3159 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 3053 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); | 3160 | try dwarf.strp(&dwarf.debug_str, di_nw, name_nav.name.toSlice(ip)); |
| 3054 | } else { | 3161 | } else { |
| 3055 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 3162 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 3056 | ip.namespacePtr(namespace).parent.unwrap().?, | 3163 | ip.namespacePtr(namespace).parent.unwrap().?, |
| 3057 | ).owner_type); | 3164 | ).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) { |
| 3059 | .@"struct" => .type_decl_incomplete_struct, | 3166 | .@"struct" => .type_decl_incomplete_struct, |
| 3060 | .@"union" => .type_decl_incomplete_union, | 3167 | .@"union" => .type_decl_incomplete_union, |
| 3061 | .@"enum" => .type_decl_incomplete_enum, | 3168 | .@"enum" => .type_decl_incomplete_enum, |
| ... | @@ -3063,16 +3170,16 @@ fn updateConstIncompleteInner( | ... | @@ -3063,16 +3170,16 @@ fn updateConstIncompleteInner( |
| 3063 | .@"struct" => .type_decl_empty_incomplete_struct, | 3170 | .@"struct" => .type_decl_empty_incomplete_struct, |
| 3064 | .@"union" => .type_decl_empty_incomplete_union, | 3171 | .@"union" => .type_decl_empty_incomplete_union, |
| 3065 | .@"enum" => .type_decl_empty_incomplete_enum, | 3172 | .@"enum" => .type_decl_empty_incomplete_enum, |
| 3066 | })); | 3173 | }); |
| 3067 | try dwarf.secOffset(di_nw, parent_ni, 0); | 3174 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 3068 | try diw.writeInt(u32, src_line + 1, dwarf.endian); | 3175 | try di_w.writeInt(u32, src_line + 1, dwarf.endian); |
| 3069 | try diw.writeUleb128(src_column + 1); | 3176 | try di_w.writeUleb128(src_column + 1); |
| 3070 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); | 3177 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); |
| 3071 | } | 3178 | } |
| 3072 | try dwarf.genCaptures(pt, di_nw, captures); | 3179 | 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)); |
| 3074 | } | 3181 | } |
| 3075 | try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen()); | 3182 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); |
| 3076 | } | 3183 | } |
| 3077 | | 3184 | |
| 3078 | fn genCaptures( | 3185 | fn genCaptures( |
| ... | @@ -3083,36 +3190,35 @@ fn genCaptures( | ... | @@ -3083,36 +3190,35 @@ fn genCaptures( |
| 3083 | ) link.EmitError!void { | 3190 | ) link.EmitError!void { |
| 3084 | const zcu = pt.zcu; | 3191 | const zcu = pt.zcu; |
| 3085 | const ip = &zcu.intern_pool; | 3192 | const ip = &zcu.intern_pool; |
| 3086 | const diw = &di_nw.interface; | | |
| 3087 | for (captures.get(ip)) |capture| switch (capture.unwrap()) { | 3193 | for (captures.get(ip)) |capture| switch (capture.unwrap()) { |
| 3088 | .@"comptime" => |capture_val| { | 3194 | .@"comptime" => |capture_val| { |
| 3089 | const ty: Type = .fromInterned(ip.typeOf(capture_val)); | 3195 | const ty: Type = .fromInterned(ip.typeOf(capture_val)); |
| 3090 | const ty_class = ty.classify(zcu); | 3196 | 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) { |
| 3092 | .no_possible_value => unreachable, | 3198 | .no_possible_value => unreachable, |
| 3093 | .one_possible_value => .comptime_capture, | 3199 | .one_possible_value => .comptime_capture, |
| 3094 | .runtime => .comptime_capture_runtime, | 3200 | .runtime => .comptime_capture_runtime, |
| 3095 | .partially_comptime => .comptime_capture_partially_comptime, | 3201 | .partially_comptime => .comptime_capture_partially_comptime, |
| 3096 | .fully_comptime => .comptime_capture_fully_comptime, | 3202 | .fully_comptime => .comptime_capture_fully_comptime, |
| 3097 | })); | 3203 | }); |
| 3098 | try dwarf.refType(pt, di_nw, ty); | 3204 | try dwarf.refType(pt, di_nw, ty); |
| 3099 | if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, .fromInterned(capture_val)); | 3205 | if (ty_class.hasRuntimeBits()) try dwarf.blockConst(pt, di_nw, .fromInterned(capture_val)); |
| 3100 | if (ty_class.comptimeOnly()) try dwarf.refConst(pt, di_nw, .fromInterned(capture_val)); | 3206 | if (ty_class.comptimeOnly()) try dwarf.refConst(pt, di_nw, .fromInterned(capture_val)); |
| 3101 | }, | 3207 | }, |
| 3102 | .runtime => |capture_ty| { | 3208 | .runtime => |capture_ty| { |
| 3103 | try diw.writeUleb128(try dwarf.refAbbrevCode(.runtime_capture)); | 3209 | try dwarf.abbrevCode(di_nw, .runtime_capture); |
| 3104 | try dwarf.refType(pt, di_nw, .fromInterned(capture_ty)); | 3210 | try dwarf.refType(pt, di_nw, .fromInterned(capture_ty)); |
| 3105 | }, | 3211 | }, |
| 3106 | .nav_val => |capture_nav| { | 3212 | .nav_val => |capture_nav| { |
| 3107 | const gi = try dwarf.getGlobal(capture_nav); | 3213 | const gi = try dwarf.getGlobal(capture_nav); |
| 3108 | try diw.writeUleb128(try dwarf.refAbbrevCode(.nav_capture)); | 3214 | try dwarf.abbrevCode(di_nw, .nav_capture); |
| 3109 | try dwarf.exprLoc(di_nw, .{ .implicit_pointer = .{ | 3215 | try dwarf.exprLoc(di_nw, .{ .implicit_pointer = .{ |
| 3110 | .node = gi.get(dwarf).debug_info_ni.unwrap().?, | 3216 | .node = gi.get(dwarf).debug_info_ni.unwrap().?, |
| 3111 | } }); | 3217 | } }); |
| 3112 | }, | 3218 | }, |
| 3113 | .nav_ref => |capture_nav| { | 3219 | .nav_ref => |capture_nav| { |
| 3114 | const gi = try dwarf.getGlobal(capture_nav); | 3220 | const gi = try dwarf.getGlobal(capture_nav); |
| 3115 | try diw.writeUleb128(try dwarf.refAbbrevCode(.nav_capture)); | 3221 | try dwarf.abbrevCode(di_nw, .nav_capture); |
| 3116 | try dwarf.exprLoc(di_nw, .{ .stack_value = &.{ .implicit_pointer = .{ | 3222 | try dwarf.exprLoc(di_nw, .{ .stack_value = &.{ .implicit_pointer = .{ |
| 3117 | .node = gi.get(dwarf).debug_info_ni.unwrap().?, | 3223 | .node = gi.get(dwarf).debug_info_ni.unwrap().?, |
| 3118 | } } }); | 3224 | } } }); |
| ... | @@ -3140,14 +3246,14 @@ fn genDeclInner( | ... | @@ -3140,14 +3246,14 @@ fn genDeclInner( |
| 3140 | ) link.EmitError!void { | 3246 | ) link.EmitError!void { |
| 3141 | const zcu = pt.zcu; | 3247 | const zcu = pt.zcu; |
| 3142 | const ip = &zcu.intern_pool; | 3248 | const ip = &zcu.intern_pool; |
| 3143 | const diw = &di_nw.interface; | 3249 | const di_w = &di_nw.interface; |
| 3144 | done: { | 3250 | done: { |
| 3145 | 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)) { | 3251 | 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)) { |
| 3146 | else => unreachable, | 3252 | else => unreachable, |
| 3147 | .struct_type => { | 3253 | .struct_type => { |
| 3148 | const loaded_struct = ip.loadStructType(instance_val); | 3254 | const loaded_struct = ip.loadStructType(instance_val); |
| 3149 | const src_inst = loaded_struct.zir_index.resolveFull(ip) orelse { | 3255 | 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); |
| 3151 | break :done; | 3257 | break :done; |
| 3152 | }; | 3258 | }; |
| 3153 | const zf = zcu.fileByIndex(src_inst.file); | 3259 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -3155,11 +3261,17 @@ fn genDeclInner( | ... | @@ -3155,11 +3261,17 @@ fn genDeclInner( |
| 3155 | const src_line, const src_column, const capture_names = decl: switch (inst.tag) { | 3261 | const src_line, const src_column, const capture_names = decl: switch (inst.tag) { |
| 3156 | else => unreachable, | 3262 | else => unreachable, |
| 3157 | .struct_init, .struct_init_ref => { | 3263 | .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; |
| 3159 | break :decl .{ decl.src_line, decl.src_column, &.{} }; | 3268 | break :decl .{ decl.src_line, decl.src_column, &.{} }; |
| 3160 | }, | 3269 | }, |
| 3161 | .struct_init_anon => { | 3270 | .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; |
| 3163 | break :decl .{ decl.src_line, decl.src_column, &.{} }; | 3275 | break :decl .{ decl.src_line, decl.src_column, &.{} }; |
| 3164 | }, | 3276 | }, |
| 3165 | .extended => switch (inst.data.extended.opcode) { | 3277 | .extended => switch (inst.data.extended.opcode) { |
| ... | @@ -3169,7 +3281,10 @@ fn genDeclInner( | ... | @@ -3169,7 +3281,10 @@ fn genDeclInner( |
| 3169 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; | 3281 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; |
| 3170 | }, | 3282 | }, |
| 3171 | .reify_struct => { | 3283 | .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; |
| 3173 | break :decl .{ decl.src_line, decl.src_column, &.{} }; | 3288 | break :decl .{ decl.src_line, decl.src_column, &.{} }; |
| 3174 | }, | 3289 | }, |
| 3175 | }, | 3290 | }, |
| ... | @@ -3189,7 +3304,7 @@ fn genDeclInner( | ... | @@ -3189,7 +3304,7 @@ fn genDeclInner( |
| 3189 | .union_type => { | 3304 | .union_type => { |
| 3190 | const loaded_union = ip.loadUnionType(instance_val); | 3305 | const loaded_union = ip.loadUnionType(instance_val); |
| 3191 | const src_inst = loaded_union.zir_index.resolveFull(ip) orelse { | 3306 | 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); |
| 3193 | break :done; | 3308 | break :done; |
| 3194 | }; | 3309 | }; |
| 3195 | const zf = zcu.fileByIndex(src_inst.file); | 3310 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -3203,7 +3318,10 @@ fn genDeclInner( | ... | @@ -3203,7 +3318,10 @@ fn genDeclInner( |
| 3203 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; | 3318 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; |
| 3204 | }, | 3319 | }, |
| 3205 | .reify_union => { | 3320 | .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; |
| 3207 | break :decl .{ decl.src_line, decl.src_column, &.{} }; | 3325 | break :decl .{ decl.src_line, decl.src_column, &.{} }; |
| 3208 | }, | 3326 | }, |
| 3209 | }, | 3327 | }, |
| ... | @@ -3223,7 +3341,7 @@ fn genDeclInner( | ... | @@ -3223,7 +3341,7 @@ fn genDeclInner( |
| 3223 | .enum_type => { | 3341 | .enum_type => { |
| 3224 | const loaded_enum = ip.loadEnumType(instance_val); | 3342 | const loaded_enum = ip.loadEnumType(instance_val); |
| 3225 | const src_inst = loaded_enum.zir_index.unwrap().?.resolveFull(ip) orelse { | 3343 | 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); |
| 3227 | break :done; | 3345 | break :done; |
| 3228 | }; | 3346 | }; |
| 3229 | const zf = zcu.fileByIndex(src_inst.file); | 3347 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -3237,7 +3355,10 @@ fn genDeclInner( | ... | @@ -3237,7 +3355,10 @@ fn genDeclInner( |
| 3237 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; | 3355 | break :decl .{ decl.src_line, decl.src_column, decl.capture_names }; |
| 3238 | }, | 3356 | }, |
| 3239 | .reify_enum => { | 3357 | .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; |
| 3241 | break :decl .{ decl.src_line, decl.src_column, &.{} }; | 3362 | break :decl .{ decl.src_line, decl.src_column, &.{} }; |
| 3242 | }, | 3363 | }, |
| 3243 | }, | 3364 | }, |
| ... | @@ -3257,7 +3378,7 @@ fn genDeclInner( | ... | @@ -3257,7 +3378,7 @@ fn genDeclInner( |
| 3257 | .opaque_type => { | 3378 | .opaque_type => { |
| 3258 | const loaded_opaque = ip.loadOpaqueType(instance_val); | 3379 | const loaded_opaque = ip.loadOpaqueType(instance_val); |
| 3259 | const src_inst = loaded_opaque.zir_index.resolveFull(ip) orelse { | 3380 | 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); |
| 3261 | break :done; | 3382 | break :done; |
| 3262 | }; | 3383 | }; |
| 3263 | const zf = zcu.fileByIndex(src_inst.file); | 3384 | const zf = zcu.fileByIndex(src_inst.file); |
| ... | @@ -3281,7 +3402,7 @@ fn genDeclInner( | ... | @@ -3281,7 +3402,7 @@ fn genDeclInner( |
| 3281 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 3402 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 3282 | name_nav.analysis.?.namespace, | 3403 | name_nav.analysis.?.namespace, |
| 3283 | ).owner_type); | 3404 | ).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) { |
| 3285 | .@"struct" => .decl_specification_struct, | 3406 | .@"struct" => .decl_specification_struct, |
| 3286 | .@"union" => .decl_specification_union, | 3407 | .@"union" => .decl_specification_union, |
| 3287 | .@"enum" => .decl_specification_enum, | 3408 | .@"enum" => .decl_specification_enum, |
| ... | @@ -3289,17 +3410,17 @@ fn genDeclInner( | ... | @@ -3289,17 +3410,17 @@ fn genDeclInner( |
| 3289 | .@"struct" => .decl_specification_empty_struct, | 3410 | .@"struct" => .decl_specification_empty_struct, |
| 3290 | .@"union" => .decl_specification_empty_union, | 3411 | .@"union" => .decl_specification_empty_union, |
| 3291 | .@"enum" => .decl_specification_empty_enum, | 3412 | .@"enum" => .decl_specification_empty_enum, |
| 3292 | })); | 3413 | }); |
| 3293 | try dwarf.secOffset(di_nw, parent_ni, 0); | 3414 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 3294 | try diw.writeInt(u32, decl.src_line + 1, dwarf.endian); | 3415 | try di_w.writeInt(u32, decl.src_line + 1, dwarf.endian); |
| 3295 | try diw.writeUleb128(decl.src_column + 1); | 3416 | try di_w.writeUleb128(decl.src_column + 1); |
| 3296 | try diw.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); | 3417 | try di_w.writeByte(if (decl.is_pub) DW.ACCESS.public else DW.ACCESS.private); |
| 3297 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); | 3418 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); |
| 3298 | } else { | 3419 | } else { |
| 3299 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( | 3420 | const parent_ni = try dwarf.getDecl(pt, ip.namespacePtr( |
| 3300 | ip.namespacePtr(namespace).parent.unwrap().?, | 3421 | ip.namespacePtr(namespace).parent.unwrap().?, |
| 3301 | ).owner_type); | 3422 | ).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) { |
| 3303 | .@"struct" => .type_decl_specification_struct, | 3424 | .@"struct" => .type_decl_specification_struct, |
| 3304 | .@"union" => .type_decl_specification_union, | 3425 | .@"union" => .type_decl_specification_union, |
| 3305 | .@"enum" => .type_decl_specification_enum, | 3426 | .@"enum" => .type_decl_specification_enum, |
| ... | @@ -3307,14 +3428,14 @@ fn genDeclInner( | ... | @@ -3307,14 +3428,14 @@ fn genDeclInner( |
| 3307 | .@"struct" => .type_decl_specification_empty_struct, | 3428 | .@"struct" => .type_decl_specification_empty_struct, |
| 3308 | .@"union" => .type_decl_specification_empty_union, | 3429 | .@"union" => .type_decl_specification_empty_union, |
| 3309 | .@"enum" => .type_decl_specification_empty_enum, | 3430 | .@"enum" => .type_decl_specification_empty_enum, |
| 3310 | })); | 3431 | }); |
| 3311 | try dwarf.secOffset(di_nw, parent_ni, 0); | 3432 | try dwarf.secOffset(di_nw, parent_ni, 0); |
| 3312 | try diw.writeInt(u32, src_line + 1, dwarf.endian); | 3433 | try di_w.writeInt(u32, src_line + 1, dwarf.endian); |
| 3313 | try diw.writeUleb128(src_column + 1); | 3434 | try di_w.writeUleb128(src_column + 1); |
| 3314 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); | 3435 | try dwarf.strp(&dwarf.debug_str, di_nw, name.toSlice(ip)); |
| 3315 | } | 3436 | } |
| 3316 | for (capture_names, captures.get(ip)) |capture_name, capture| { | 3437 | 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); |
| 3318 | switch (capture.unwrap()) { | 3439 | switch (capture.unwrap()) { |
| 3319 | .@"comptime", .runtime, .nav_val => try dwarf.strp( | 3440 | .@"comptime", .runtime, .nav_val => try dwarf.strp( |
| 3320 | &dwarf.debug_str, | 3441 | &dwarf.debug_str, |
| ... | @@ -3330,9 +3451,9 @@ fn genDeclInner( | ... | @@ -3330,9 +3451,9 @@ fn genDeclInner( |
| 3330 | }, | 3451 | }, |
| 3331 | } | 3452 | } |
| 3332 | } | 3453 | } |
| 3333 | if (captures.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null)); | 3454 | if (captures.len > 0) try di_w.writeUleb128(@backingInt(AbbrevCode.null)); |
| 3334 | } | 3455 | } |
| 3335 | try dwarf.genDebugInfoPadding(diw, diw.unusedCapacityLen()); | 3456 | try dwarf.genDebugInfoPadding(di_w, di_w.unusedCapacityLen()); |
| 3336 | } | 3457 | } |
| 3337 | | 3458 | |
| 3338 | pub fn updateLineNumber( | 3459 | pub fn updateLineNumber( |
| ... | @@ -3351,8 +3472,8 @@ pub fn updateLineNumber( | ... | @@ -3351,8 +3472,8 @@ pub fn updateLineNumber( |
| 3351 | ); | 3472 | ); |
| 3352 | } | 3473 | } |
| 3353 | | 3474 | |
| 3354 | pub fn lostTracking(dwarf: *Dwarf, diw: *std.Io.Writer) link.EmitError!void { | 3475 | pub fn lostTracking(dwarf: *Dwarf, di_nw: *MappedFile.Node.Writer) link.EmitError!void { |
| 3355 | try diw.writeUleb128(try dwarf.refAbbrevCode(.decl_lost)); | 3476 | try dwarf.abbrevCode(di_nw, .decl_lost); |
| 3356 | } | 3477 | } |
| 3357 | | 3478 | |
| 3358 | fn refAbbrevCodeIfExists( | 3479 | fn refAbbrevCodeIfExists( |
| ... | @@ -3362,9 +3483,9 @@ fn refAbbrevCodeIfExists( | ... | @@ -3362,9 +3483,9 @@ fn refAbbrevCodeIfExists( |
| 3362 | assert(abbrev_code != .null); | 3483 | assert(abbrev_code != .null); |
| 3363 | return if (dwarf.debug_abbrev.set.contains(abbrev_code)) @backingInt(abbrev_code) else null; | 3484 | return if (dwarf.debug_abbrev.set.contains(abbrev_code)) @backingInt(abbrev_code) else null; |
| 3364 | } | 3485 | } |
| 3365 | | | |
| 3366 | fn refAbbrevCode( | 3486 | fn refAbbrevCode( |
| 3367 | dwarf: *Dwarf, | 3487 | dwarf: *Dwarf, |
| | 3488 | mf: *MappedFile, |
| 3368 | abbrev_code: AbbrevCode, | 3489 | abbrev_code: AbbrevCode, |
| 3369 | ) link.Error!@typeInfo(AbbrevCode).@"enum".tag_type { | 3490 | ) link.Error!@typeInfo(AbbrevCode).@"enum".tag_type { |
| 3370 | if (dwarf.refAbbrevCodeIfExists(abbrev_code)) |backing_int| { | 3491 | if (dwarf.refAbbrevCodeIfExists(abbrev_code)) |backing_int| { |
| ... | @@ -3372,7 +3493,7 @@ fn refAbbrevCode( | ... | @@ -3372,7 +3493,7 @@ fn refAbbrevCode( |
| 3372 | return backing_int; | 3493 | return backing_int; |
| 3373 | } | 3494 | } |
| 3374 | var da_nw: MappedFile.Node.Writer = undefined; | 3495 | 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); |
| 3376 | defer da_nw.deinit(); | 3497 | defer da_nw.deinit(); |
| 3377 | dwarf.genDebugAbbrev(&da_nw, abbrev_code) catch |err| switch (err) { | 3498 | dwarf.genDebugAbbrev(&da_nw, abbrev_code) catch |err| switch (err) { |
| 3378 | else => |e| return e, | 3499 | else => |e| return e, |
| ... | @@ -3381,6 +3502,13 @@ fn refAbbrevCode( | ... | @@ -3381,6 +3502,13 @@ fn refAbbrevCode( |
| 3381 | dwarf.debug_abbrev.set.insert(abbrev_code); | 3502 | dwarf.debug_abbrev.set.insert(abbrev_code); |
| 3382 | return dwarf.refAbbrevCodeIfExists(abbrev_code).?; | 3503 | return dwarf.refAbbrevCodeIfExists(abbrev_code).?; |
| 3383 | } | 3504 | } |
| | 3505 | fn 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 | } |
| 3384 | | 3512 | |
| 3385 | fn genDebugAbbrev( | 3513 | fn genDebugAbbrev( |
| 3386 | dwarf: *Dwarf, | 3514 | dwarf: *Dwarf, |
| ... | @@ -3388,20 +3516,20 @@ fn genDebugAbbrev( | ... | @@ -3388,20 +3516,20 @@ fn genDebugAbbrev( |
| 3388 | abbrev_code: AbbrevCode, | 3516 | abbrev_code: AbbrevCode, |
| 3389 | ) link.EmitError!void { | 3517 | ) link.EmitError!void { |
| 3390 | const abbrev = AbbrevCode.abbrevs.get(abbrev_code); | 3518 | const abbrev = AbbrevCode.abbrevs.get(abbrev_code); |
| 3391 | const daw = &da_nw.interface; | 3519 | const da_w = &da_nw.interface; |
| 3392 | daw.end = dwarf.debug_abbrev.end; | 3520 | da_w.end = dwarf.debug_abbrev.end; |
| 3393 | try daw.writeUleb128(@backingInt(abbrev_code)); | 3521 | try da_w.writeUleb128(@backingInt(abbrev_code)); |
| 3394 | try daw.writeUleb128(@backingInt(abbrev.tag)); | 3522 | try da_w.writeUleb128(@backingInt(abbrev.tag)); |
| 3395 | try daw.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no); | 3523 | try da_w.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no); |
| 3396 | for (abbrev.attrs) |*attr| { | 3524 | for (abbrev.attrs) |*attr| { |
| 3397 | try daw.writeUleb128(@backingInt(switch (attr[0]) { | 3525 | try da_w.writeUleb128(@backingInt(switch (attr[0]) { |
| 3398 | else => |at| at, | 3526 | else => |at| at, |
| 3399 | .ZIG_call_line_relative => |at| if (dwarf.lf.comp.config.incremental) at else .call_line, | 3527 | .ZIG_call_line_relative => |at| if (dwarf.lf.comp.config.incremental) at else .call_line, |
| 3400 | })); | 3528 | })); |
| 3401 | try daw.writeUleb128(@backingInt(attr[1])); | 3529 | try da_w.writeUleb128(@backingInt(attr[1])); |
| 3402 | } | 3530 | } |
| 3403 | for (0..2) |_| try daw.writeUleb128(0); | 3531 | for (0..2) |_| try da_w.writeUleb128(0); |
| 3404 | dwarf.debug_abbrev.end = daw.end; | 3532 | dwarf.debug_abbrev.end = da_w.end; |
| 3405 | } | 3533 | } |
| 3406 | | 3534 | |
| 3407 | pub fn secOffsetSize(dwarf: *Dwarf) usize { | 3535 | pub fn secOffsetSize(dwarf: *Dwarf) usize { |
| ... | @@ -3421,11 +3549,16 @@ fn secOffset( | ... | @@ -3421,11 +3549,16 @@ fn secOffset( |
| 3421 | ) link.EmitError!void { | 3549 | ) link.EmitError!void { |
| 3422 | const offset = nw.interface.end; | 3550 | const offset = nw.interface.end; |
| 3423 | try dwarf.secOffsetPlaceholder(&nw.interface); | 3551 | try dwarf.secOffsetPlaceholder(&nw.interface); |
| 3424 | const elf = dwarf.lf.cast(.elf2).?; | 3552 | if (dwarf.lf.cast(.elf2)) |elf| try elf.addNodeReloc( |
| 3425 | try elf.addNodeReloc(nw.ni, offset, target_ni, @bitCast(@as(u64, addend)), switch (dwarf.format) { | 3553 | nw.ni, |
| 3426 | .@"32" => .abs32, | 3554 | offset, |
| 3427 | .@"64" => .abs64, | 3555 | target_ni, |
| 3428 | }); | 3556 | @bitCast(@as(u64, addend)), |
| | 3557 | switch (dwarf.format) { |
| | 3558 | .@"32" => .abs32, |
| | 3559 | .@"64" => .abs64, |
| | 3560 | }, |
| | 3561 | ) else unreachable; |
| 3429 | } | 3562 | } |
| 3430 | | 3563 | |
| 3431 | fn addrPlaceholder(dwarf: *Dwarf, w: *std.Io.Writer) std.Io.Writer.Error!void { | 3564 | fn addrPlaceholder(dwarf: *Dwarf, w: *std.Io.Writer) std.Io.Writer.Error!void { |
| ... | @@ -3439,8 +3572,13 @@ fn addrSym( | ... | @@ -3439,8 +3572,13 @@ fn addrSym( |
| 3439 | ) link.EmitError!void { | 3572 | ) link.EmitError!void { |
| 3440 | const offset = nw.interface.end; | 3573 | const offset = nw.interface.end; |
| 3441 | try dwarf.addrPlaceholder(&nw.interface); | 3574 | try dwarf.addrPlaceholder(&nw.interface); |
| 3442 | const elf = dwarf.lf.cast(.elf2).?; | 3575 | if (dwarf.lf.cast(.elf2)) |elf| try elf.addReloc( |
| 3443 | try elf.addReloc(@bitCast(nw.ni), offset, target_si, @bitCast(@as(u64, addend)), .absAddr(elf)); | 3576 | @bitCast(nw.ni), |
| | 3577 | offset, |
| | 3578 | target_si, |
| | 3579 | @bitCast(@as(u64, addend)), |
| | 3580 | .absAddr(elf), |
| | 3581 | ) else unreachable; |
| 3444 | } | 3582 | } |
| 3445 | | 3583 | |
| 3446 | fn blockConst( | 3584 | fn blockConst( |
| ... | @@ -3482,7 +3620,7 @@ fn refConst( | ... | @@ -3482,7 +3620,7 @@ fn refConst( |
| 3482 | | 3620 | |
| 3483 | fn bigIntConstValue( | 3621 | fn bigIntConstValue( |
| 3484 | dwarf: *Dwarf, | 3622 | dwarf: *Dwarf, |
| 3485 | diw: *std.Io.Writer, | 3623 | di_w: *std.Io.Writer, |
| 3486 | ty: Type, | 3624 | ty: Type, |
| 3487 | big_int: std.math.big.int.Const, | 3625 | big_int: std.math.big.int.Const, |
| 3488 | ) link.EmitError!void { | 3626 | ) link.EmitError!void { |
| ... | @@ -3493,18 +3631,20 @@ fn bigIntConstValue( | ... | @@ -3493,18 +3631,20 @@ fn bigIntConstValue( |
| 3493 | }; | 3631 | }; |
| 3494 | const bits = @max(1, big_int.bitCountTwosCompForSignedness(signedness)); | 3632 | const bits = @max(1, big_int.bitCountTwosCompForSignedness(signedness)); |
| 3495 | if (bits <= 64) { | 3633 | if (bits <= 64) { |
| 3496 | try diw.writeUleb128(@as(u13, switch (signedness) { | 3634 | try di_w.writeUleb128(@as(u13, switch (signedness) { |
| 3497 | .signed => DW.FORM.sdata, | 3635 | .signed => DW.FORM.sdata, |
| 3498 | .unsigned => DW.FORM.udata, | 3636 | .unsigned => DW.FORM.udata, |
| 3499 | })); | 3637 | })); |
| 3500 | var bit: usize = 0; | 3638 | var bit: usize = 0; |
| 3501 | var carry: u1 = 1; | 3639 | var carry: u1 = 1; |
| 3502 | for (try diw.writableSlice(@divCeil(bits, 7))) |*byte| { | 3640 | for (try di_w.writableSlice(@divCeil(bits, 7))) |*byte| { |
| 3503 | const limb_bits = @typeInfo(std.math.big.Limb).int.bits; | 3641 | const limb_bits = @typeInfo(std.math.big.Limb).int.bits; |
| 3504 | const limb_index = bit / limb_bits; | 3642 | const limb_index = bit / limb_bits; |
| 3505 | const limb_shift: std.math.Log2Int(std.math.big.Limb) = @intCast(bit % limb_bits); | 3643 | const limb_shift: std.math.Log2Int(std.math.big.Limb) = @intCast(bit % limb_bits); |
| 3506 | const low_abs_part: u7 = @truncate(big_int.limbs[limb_index] >> limb_shift); | 3644 | 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: { |
| 3508 | const high_abs_part: u7 = @truncate(big_int.limbs[limb_index + 1] << -%limb_shift); | 3648 | const high_abs_part: u7 = @truncate(big_int.limbs[limb_index + 1] << -%limb_shift); |
| 3509 | break :abs_part high_abs_part | low_abs_part; | 3649 | break :abs_part high_abs_part | low_abs_part; |
| 3510 | } else low_abs_part; | 3650 | } else low_abs_part; |
| ... | @@ -3516,28 +3656,33 @@ fn bigIntConstValue( | ... | @@ -3516,28 +3656,33 @@ fn bigIntConstValue( |
| 3516 | byte.* = @as(u8, if (bit < bits) 0x80 else 0x00) | twos_comp_part; | 3656 | byte.* = @as(u8, if (bit < bits) 0x80 else 0x00) | twos_comp_part; |
| 3517 | } | 3657 | } |
| 3518 | } else { | 3658 | } else { |
| 3519 | try diw.writeUleb128(DW.FORM.block); | 3659 | try di_w.writeUleb128(DW.FORM.block); |
| 3520 | const size = switch (ty.toIntern()) { | 3660 | const size = switch (ty.toIntern()) { |
| 3521 | .comptime_int_type => @divCeil(bits, 8), | 3661 | .comptime_int_type => @divCeil(bits, 8), |
| 3522 | else => ty.abiSize(zcu), | 3662 | else => ty.abiSize(zcu), |
| 3523 | }; | 3663 | }; |
| 3524 | try diw.writeUleb128(size); | 3664 | try di_w.writeUleb128(size); |
| 3525 | big_int.writeTwosComplement(try diw.writableSlice(@intCast(size)), dwarf.endian); | 3665 | big_int.writeTwosComplement(try di_w.writableSlice(@intCast(size)), dwarf.endian); |
| 3526 | } | 3666 | } |
| 3527 | } | 3667 | } |
| 3528 | | 3668 | |
| 3529 | fn enumConstValue( | 3669 | fn enumConstValue( |
| 3530 | dwarf: *Dwarf, | 3670 | dwarf: *Dwarf, |
| 3531 | diw: *std.Io.Writer, | 3671 | di_w: *std.Io.Writer, |
| 3532 | loaded_enum: InternPool.LoadedEnumType, | 3672 | loaded_enum: InternPool.LoadedEnumType, |
| 3533 | field_index: usize, | 3673 | field_index: usize, |
| 3534 | ) link.EmitError!void { | 3674 | ) link.EmitError!void { |
| 3535 | const zcu = dwarf.lf.comp.zcu.?; | 3675 | const zcu = dwarf.lf.comp.zcu.?; |
| 3536 | var big_int_space: Value.BigIntSpace = undefined; | 3676 | 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) | 3677 | try dwarf.bigIntConstValue( |
| 3538 | Value.fromInterned(loaded_enum.field_values.get(&zcu.intern_pool)[field_index]).toBigInt(&big_int_space, zcu) | 3678 | di_w, |
| 3539 | else | 3679 | .fromInterned(loaded_enum.int_tag_type), |
| 3540 | std.math.big.int.Mutable.init(&big_int_space.limbs, field_index).toConst()); | 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 | ); |
| 3541 | } | 3686 | } |
| 3542 | | 3687 | |
| 3543 | fn exprLoc(dwarf: *Dwarf, nw: *MappedFile.Node.Writer, loc: Loc) link.EmitError!void { | 3688 | fn exprLoc(dwarf: *Dwarf, nw: *MappedFile.Node.Writer, loc: Loc) link.EmitError!void { |
| ... | @@ -3577,7 +3722,8 @@ fn DeclValEnum(comptime T: type) type { | ... | @@ -3577,7 +3722,8 @@ fn DeclValEnum(comptime T: type) type { |
| 3577 | var min_value: ?comptime_int = null; | 3722 | var min_value: ?comptime_int = null; |
| 3578 | var max_value: ?comptime_int = null; | 3723 | var max_value: ?comptime_int = null; |
| 3579 | for (decl_names) |decl_name| { | 3724 | 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; |
| 3581 | const value = @field(T, decl_name); | 3727 | const value = @field(T, decl_name); |
| 3582 | field_names[fields_len] = decl_name; | 3728 | field_names[fields_len] = decl_name; |
| 3583 | fields_len += 1; | 3729 | fields_len += 1; |
Jacob Young <jacobly@ziglang.org> 2026-09-02 10:17:31-04:00
src