authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-06-07 00:22:36+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-06-07 00:22:36+02:00
log920f1dcd2784bf00350843872620f5d64085e267
tree7e231a1e2753d11d2d6aae9388488a130f3eab51
parent367e2b2fe43a2de09767ad8d5657866088b44678
parente05de31a5fa8105b09eed37c9d023501b1289cd1
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11804 from ziglang/elf-dwarf-unions

dwarf: fix incorrect type relocations for union payloads

7 files changed, 130 insertions(+), 82 deletions(-)

src/arch/arm/CodeGen.zig+1-1
......@@ -3187,7 +3187,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) error{OutOfMemory}!void {
31873187 .macho => unreachable,
31883188 else => unreachable,
31893189 };
3190 try dw.addTypeReloc(atom, ty, @intCast(u32, index), null);
3190 try dw.addTypeRelocGlobal(atom, ty, @intCast(u32, index));
31913191 },
31923192 .plan9 => {},
31933193 .none => {},
src/arch/riscv64/CodeGen.zig+1-1
......@@ -754,7 +754,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {
754754 .macho => unreachable,
755755 else => unreachable,
756756 };
757 try dw.addTypeReloc(atom, ty, @intCast(u32, index), null);
757 try dw.addTypeRelocGlobal(atom, ty, @intCast(u32, index));
758758 },
759759 .plan9 => {},
760760 .none => {},
src/arch/sparc64/CodeGen.zig+1-1
......@@ -1550,7 +1550,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {
15501550 .elf => &mod.declPtr(self.mod_fn.owner_decl).link.elf.dbg_info_atom,
15511551 else => unreachable,
15521552 };
1553 try dw.addTypeReloc(atom, ty, @intCast(u32, index), null);
1553 try dw.addTypeRelocGlobal(atom, ty, @intCast(u32, index));
15541554 },
15551555 else => {},
15561556 }
src/arch/wasm/CodeGen.zig+1-1
......@@ -1050,7 +1050,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {
10501050 const index = dbg_info.items.len;
10511051 try dbg_info.resize(index + 4);
10521052 const atom = &self.decl.link.wasm.dbg_info_atom;
1053 try dwarf.addTypeReloc(atom, ty, @intCast(u32, index), null);
1053 try dwarf.addTypeRelocGlobal(atom, ty, @intCast(u32, index));
10541054 },
10551055 .plan9 => unreachable,
10561056 .none => {},
src/arch/x86_64/CodeGen.zig+1-1
......@@ -4371,7 +4371,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {
43714371 .macho => &fn_owner_decl.link.macho.dbg_info_atom,
43724372 else => unreachable,
43734373 };
4374 try dw.addTypeReloc(atom, ty, @intCast(u32, index), null);
4374 try dw.addTypeRelocGlobal(atom, ty, @intCast(u32, index));
43754375 },
43764376 .plan9 => {},
43774377 .none => {},
src/link/Dwarf.zig+64-51
......@@ -110,13 +110,22 @@ pub const DeclState = struct {
110110 });
111111 }
112112
113 pub fn addTypeReloc(
114 self: *DeclState,
115 atom: *const Atom,
116 ty: Type,
117 offset: u32,
118 addend: ?u32,
119 ) !void {
113 /// Adds local type relocation of the form: @offset => @this + addend
114 /// @this signifies the offset within the .debug_abbrev section of the containing atom.
115 pub fn addTypeRelocLocal(self: *DeclState, atom: *const Atom, offset: u32, addend: u32) !void {
116 log.debug("{x}: @this + {x}", .{ offset, addend });
117 try self.abbrev_relocs.append(self.gpa, .{
118 .target = null,
119 .atom = atom,
120 .offset = offset,
121 .addend = addend,
122 });
123 }
124
125 /// Adds global type relocation of the form: @offset => @symbol + 0
126 /// @symbol signifies a type abbreviation posititioned somewhere in the .debug_abbrev section
127 /// which we use as our target of the relocation.
128 pub fn addTypeRelocGlobal(self: *DeclState, atom: *const Atom, ty: Type, offset: u32) !void {
120129 const resolv = self.abbrev_resolver.getContext(ty, .{
121130 .mod = self.mod,
122131 }) orelse blk: {
......@@ -134,14 +143,12 @@ pub const DeclState = struct {
134143 .mod = self.mod,
135144 }).?;
136145 };
137 const add: u32 = addend orelse 0;
138
139 log.debug("{x}: @{d} + {x}", .{ offset, resolv, add });
146 log.debug("{x}: @{d} + 0", .{ offset, resolv });
140147 try self.abbrev_relocs.append(self.gpa, .{
141148 .target = resolv,
142149 .atom = atom,
143150 .offset = offset,
144 .addend = add,
151 .addend = 0,
145152 });
146153 }
147154
......@@ -213,7 +220,7 @@ pub const DeclState = struct {
213220 // DW.AT.type, DW.FORM.ref4
214221 var index = dbg_info_buffer.items.len;
215222 try dbg_info_buffer.resize(index + 4);
216 try self.addTypeReloc(atom, Type.bool, @intCast(u32, index), null);
223 try self.addTypeRelocGlobal(atom, Type.bool, @intCast(u32, index));
217224 // DW.AT.data_member_location, DW.FORM.sdata
218225 try dbg_info_buffer.ensureUnusedCapacity(6);
219226 dbg_info_buffer.appendAssumeCapacity(0);
......@@ -225,7 +232,7 @@ pub const DeclState = struct {
225232 // DW.AT.type, DW.FORM.ref4
226233 index = dbg_info_buffer.items.len;
227234 try dbg_info_buffer.resize(index + 4);
228 try self.addTypeReloc(atom, payload_ty, @intCast(u32, index), null);
235 try self.addTypeRelocGlobal(atom, payload_ty, @intCast(u32, index));
229236 // DW.AT.data_member_location, DW.FORM.sdata
230237 const offset = abi_size - payload_ty.abiSize(target);
231238 try leb128.writeULEB128(dbg_info_buffer.writer(), offset);
......@@ -254,7 +261,7 @@ pub const DeclState = struct {
254261 try dbg_info_buffer.resize(index + 4);
255262 var buf = try arena.create(Type.SlicePtrFieldTypeBuffer);
256263 const ptr_ty = ty.slicePtrFieldType(buf);
257 try self.addTypeReloc(atom, ptr_ty, @intCast(u32, index), null);
264 try self.addTypeRelocGlobal(atom, ptr_ty, @intCast(u32, index));
258265 // DW.AT.data_member_location, DW.FORM.sdata
259266 try dbg_info_buffer.ensureUnusedCapacity(6);
260267 dbg_info_buffer.appendAssumeCapacity(0);
......@@ -266,7 +273,7 @@ pub const DeclState = struct {
266273 // DW.AT.type, DW.FORM.ref4
267274 index = dbg_info_buffer.items.len;
268275 try dbg_info_buffer.resize(index + 4);
269 try self.addTypeReloc(atom, Type.usize, @intCast(u32, index), null);
276 try self.addTypeRelocGlobal(atom, Type.usize, @intCast(u32, index));
270277 // DW.AT.data_member_location, DW.FORM.sdata
271278 try dbg_info_buffer.ensureUnusedCapacity(2);
272279 dbg_info_buffer.appendAssumeCapacity(@sizeOf(usize));
......@@ -278,7 +285,7 @@ pub const DeclState = struct {
278285 // DW.AT.type, DW.FORM.ref4
279286 const index = dbg_info_buffer.items.len;
280287 try dbg_info_buffer.resize(index + 4);
281 try self.addTypeReloc(atom, ty.childType(), @intCast(u32, index), null);
288 try self.addTypeRelocGlobal(atom, ty.childType(), @intCast(u32, index));
282289 }
283290 },
284291 .Array => {
......@@ -289,13 +296,13 @@ pub const DeclState = struct {
289296 // DW.AT.type, DW.FORM.ref4
290297 var index = dbg_info_buffer.items.len;
291298 try dbg_info_buffer.resize(index + 4);
292 try self.addTypeReloc(atom, ty.childType(), @intCast(u32, index), null);
299 try self.addTypeRelocGlobal(atom, ty.childType(), @intCast(u32, index));
293300 // DW.AT.subrange_type
294301 try dbg_info_buffer.append(@enumToInt(AbbrevKind.array_dim));
295302 // DW.AT.type, DW.FORM.ref4
296303 index = dbg_info_buffer.items.len;
297304 try dbg_info_buffer.resize(index + 4);
298 try self.addTypeReloc(atom, Type.usize, @intCast(u32, index), null);
305 try self.addTypeRelocGlobal(atom, Type.usize, @intCast(u32, index));
299306 // DW.AT.count, DW.FORM.udata
300307 const len = ty.arrayLenIncludingSentinel();
301308 try leb128.writeULEB128(dbg_info_buffer.writer(), len);
......@@ -323,7 +330,7 @@ pub const DeclState = struct {
323330 // DW.AT.type, DW.FORM.ref4
324331 var index = dbg_info_buffer.items.len;
325332 try dbg_info_buffer.resize(index + 4);
326 try self.addTypeReloc(atom, field, @intCast(u32, index), null);
333 try self.addTypeRelocGlobal(atom, field, @intCast(u32, index));
327334 // DW.AT.data_member_location, DW.FORM.sdata
328335 const field_off = ty.structFieldOffset(field_index, target);
329336 try leb128.writeULEB128(dbg_info_buffer.writer(), field_off);
......@@ -354,7 +361,7 @@ pub const DeclState = struct {
354361 // DW.AT.type, DW.FORM.ref4
355362 var index = dbg_info_buffer.items.len;
356363 try dbg_info_buffer.resize(index + 4);
357 try self.addTypeReloc(atom, field.ty, @intCast(u32, index), null);
364 try self.addTypeRelocGlobal(atom, field.ty, @intCast(u32, index));
358365 // DW.AT.data_member_location, DW.FORM.sdata
359366 const field_off = ty.structFieldOffset(field_index, target);
360367 try leb128.writeULEB128(dbg_info_buffer.writer(), field_off);
......@@ -434,7 +441,7 @@ pub const DeclState = struct {
434441 // DW.AT.type, DW.FORM.ref4
435442 const inner_union_index = dbg_info_buffer.items.len;
436443 try dbg_info_buffer.resize(inner_union_index + 4);
437 try self.addTypeReloc(atom, ty, @intCast(u32, inner_union_index), 5);
444 try self.addTypeRelocLocal(atom, @intCast(u32, inner_union_index), 5);
438445 // DW.AT.data_member_location, DW.FORM.sdata
439446 try leb128.writeULEB128(dbg_info_buffer.writer(), payload_offset);
440447 }
......@@ -461,7 +468,7 @@ pub const DeclState = struct {
461468 // DW.AT.type, DW.FORM.ref4
462469 const index = dbg_info_buffer.items.len;
463470 try dbg_info_buffer.resize(index + 4);
464 try self.addTypeReloc(atom, field.ty, @intCast(u32, index), null);
471 try self.addTypeRelocGlobal(atom, field.ty, @intCast(u32, index));
465472 // DW.AT.data_member_location, DW.FORM.sdata
466473 try dbg_info_buffer.append(0);
467474 }
......@@ -478,7 +485,7 @@ pub const DeclState = struct {
478485 // DW.AT.type, DW.FORM.ref4
479486 const index = dbg_info_buffer.items.len;
480487 try dbg_info_buffer.resize(index + 4);
481 try self.addTypeReloc(atom, union_obj.tag_ty, @intCast(u32, index), null);
488 try self.addTypeRelocGlobal(atom, union_obj.tag_ty, @intCast(u32, index));
482489 // DW.AT.data_member_location, DW.FORM.sdata
483490 try leb128.writeULEB128(dbg_info_buffer.writer(), tag_offset);
484491
......@@ -521,7 +528,7 @@ pub const DeclState = struct {
521528 // DW.AT.type, DW.FORM.ref4
522529 var index = dbg_info_buffer.items.len;
523530 try dbg_info_buffer.resize(index + 4);
524 try self.addTypeReloc(atom, payload_ty, @intCast(u32, index), null);
531 try self.addTypeRelocGlobal(atom, payload_ty, @intCast(u32, index));
525532 // DW.AT.data_member_location, DW.FORM.sdata
526533 try leb128.writeULEB128(dbg_info_buffer.writer(), payload_off);
527534
......@@ -534,7 +541,7 @@ pub const DeclState = struct {
534541 // DW.AT.type, DW.FORM.ref4
535542 index = dbg_info_buffer.items.len;
536543 try dbg_info_buffer.resize(index + 4);
537 try self.addTypeReloc(atom, error_ty, @intCast(u32, index), null);
544 try self.addTypeRelocGlobal(atom, error_ty, @intCast(u32, index));
538545 // DW.AT.data_member_location, DW.FORM.sdata
539546 try leb128.writeULEB128(dbg_info_buffer.writer(), error_off);
540547
......@@ -556,7 +563,9 @@ pub const AbbrevEntry = struct {
556563};
557564
558565pub const AbbrevRelocation = struct {
559 target: u32,
566 /// If target is null, we deal with a local relocation that is based on simple offset + addend
567 /// only.
568 target: ?u32,
560569 atom: *const Atom,
561570 offset: u32,
562571 addend: u32,
......@@ -740,12 +749,7 @@ pub fn initDeclState(self: *Dwarf, mod: *Module, decl: *Module.Decl) !DeclState
740749 .wasm => &decl.link.wasm.dbg_info_atom,
741750 else => unreachable,
742751 };
743 try decl_state.addTypeReloc(
744 atom,
745 fn_ret_type,
746 @intCast(u32, dbg_info_buffer.items.len),
747 null,
748 );
752 try decl_state.addTypeRelocGlobal(atom, fn_ret_type, @intCast(u32, dbg_info_buffer.items.len));
749753 dbg_info_buffer.items.len += 4; // DW.AT.type, DW.FORM.ref4
750754 }
751755
......@@ -1036,30 +1040,39 @@ pub fn commitDeclState(
10361040 try self.updateDeclDebugInfoAllocation(file, atom, @intCast(u32, dbg_info_buffer.items.len));
10371041
10381042 while (decl_state.abbrev_relocs.popOrNull()) |reloc| {
1039 const symbol = decl_state.abbrev_table.items[reloc.target];
1040 const ty = symbol.@"type";
1041 const deferred: bool = blk: {
1042 if (ty.isAnyError()) break :blk true;
1043 switch (ty.tag()) {
1044 .error_set_inferred => {
1045 if (!ty.castTag(.error_set_inferred).?.data.is_resolved) break :blk true;
1046 },
1047 else => {},
1043 if (reloc.target) |target| {
1044 const symbol = decl_state.abbrev_table.items[target];
1045 const ty = symbol.@"type";
1046 const deferred: bool = blk: {
1047 if (ty.isAnyError()) break :blk true;
1048 switch (ty.tag()) {
1049 .error_set_inferred => {
1050 if (!ty.castTag(.error_set_inferred).?.data.is_resolved) break :blk true;
1051 },
1052 else => {},
1053 }
1054 break :blk false;
1055 };
1056 if (deferred) {
1057 try self.global_abbrev_relocs.append(gpa, .{
1058 .target = null,
1059 .offset = reloc.offset,
1060 .atom = reloc.atom,
1061 .addend = reloc.addend,
1062 });
1063 } else {
1064 mem.writeInt(
1065 u32,
1066 dbg_info_buffer.items[reloc.offset..][0..@sizeOf(u32)],
1067 symbol.atom.off + symbol.offset + reloc.addend,
1068 target_endian,
1069 );
10481070 }
1049 break :blk false;
1050 };
1051 if (deferred) {
1052 try self.global_abbrev_relocs.append(gpa, .{
1053 .target = undefined,
1054 .offset = reloc.offset,
1055 .atom = reloc.atom,
1056 .addend = reloc.addend,
1057 });
10581071 } else {
10591072 mem.writeInt(
10601073 u32,
10611074 dbg_info_buffer.items[reloc.offset..][0..@sizeOf(u32)],
1062 symbol.atom.off + symbol.offset + reloc.addend,
1075 reloc.atom.off + reloc.offset + reloc.addend,
10631076 target_endian,
10641077 );
10651078 }
src/link/Elf.zig+61-26
......@@ -497,7 +497,7 @@ fn makeString(self: *Elf, bytes: []const u8) !u32 {
497497 return @intCast(u32, result);
498498}
499499
500fn getString(self: *Elf, str_off: u32) []const u8 {
500fn getString(self: Elf, str_off: u32) []const u8 {
501501 assert(str_off < self.shstrtab.items.len);
502502 return mem.sliceTo(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + str_off), 0);
503503}
......@@ -1015,6 +1015,10 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
10151015 // mixing local and global symbols within a symbol table.
10161016 try self.writeAllGlobalSymbols();
10171017
1018 if (build_options.enable_logging) {
1019 self.logSymtab();
1020 }
1021
10181022 if (self.dwarf) |*dw| {
10191023 if (self.debug_abbrev_section_dirty) {
10201024 try dw.writeDbgAbbrev(&self.base);
......@@ -1167,7 +1171,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
11671171
11681172 for (buf) |*shdr, i| {
11691173 shdr.* = sectHeaderTo32(self.sections.items[i]);
1170 log.debug("writing section {}", .{shdr.*});
1174 log.debug("writing section {s}: {}", .{ self.getString(shdr.sh_name), shdr.* });
11711175 if (foreign_endian) {
11721176 mem.byteSwapAllFields(elf.Elf32_Shdr, shdr);
11731177 }
......@@ -1180,7 +1184,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
11801184
11811185 for (buf) |*shdr, i| {
11821186 shdr.* = self.sections.items[i];
1183 log.debug("writing section {}", .{shdr.*});
1187 log.debug("writing section {s}: {}", .{ self.getString(shdr.sh_name), shdr.* });
11841188 if (foreign_endian) {
11851189 mem.byteSwapAllFields(elf.Elf64_Shdr, shdr);
11861190 }
......@@ -2794,8 +2798,14 @@ fn writeSymbol(self: *Elf, index: usize) !void {
27942798 if (needed_size > self.allocatedSize(syms_sect.sh_offset)) {
27952799 // Move all the symbols to a new file location.
27962800 const new_offset = self.findFreeSpace(needed_size, sym_align);
2801 log.debug("moving '.symtab' from 0x{x} to 0x{x}", .{ syms_sect.sh_offset, new_offset });
27972802 const existing_size = @as(u64, syms_sect.sh_info) * sym_size;
2798 const amt = try self.base.file.?.copyRangeAll(syms_sect.sh_offset, self.base.file.?, new_offset, existing_size);
2803 const amt = try self.base.file.?.copyRangeAll(
2804 syms_sect.sh_offset,
2805 self.base.file.?,
2806 new_offset,
2807 existing_size,
2808 );
27992809 if (amt != existing_size) return error.InputOutput;
28002810 syms_sect.sh_offset = new_offset;
28012811 }
......@@ -2804,30 +2814,35 @@ fn writeSymbol(self: *Elf, index: usize) !void {
28042814 self.shdr_table_dirty = true; // TODO look into only writing one section
28052815 }
28062816 const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
2817 const off = switch (self.ptr_width) {
2818 .p32 => syms_sect.sh_offset + @sizeOf(elf.Elf32_Sym) * index,
2819 .p64 => syms_sect.sh_offset + @sizeOf(elf.Elf64_Sym) * index,
2820 };
2821 const local = self.local_symbols.items[index];
2822 log.debug("writing symbol {d}, '{s}' at 0x{x}", .{ index, self.getString(local.st_name), off });
2823 log.debug(" ({})", .{local});
28072824 switch (self.ptr_width) {
28082825 .p32 => {
28092826 var sym = [1]elf.Elf32_Sym{
28102827 .{
2811 .st_name = self.local_symbols.items[index].st_name,
2812 .st_value = @intCast(u32, self.local_symbols.items[index].st_value),
2813 .st_size = @intCast(u32, self.local_symbols.items[index].st_size),
2814 .st_info = self.local_symbols.items[index].st_info,
2815 .st_other = self.local_symbols.items[index].st_other,
2816 .st_shndx = self.local_symbols.items[index].st_shndx,
2828 .st_name = local.st_name,
2829 .st_value = @intCast(u32, local.st_value),
2830 .st_size = @intCast(u32, local.st_size),
2831 .st_info = local.st_info,
2832 .st_other = local.st_other,
2833 .st_shndx = local.st_shndx,
28172834 },
28182835 };
28192836 if (foreign_endian) {
28202837 mem.byteSwapAllFields(elf.Elf32_Sym, &sym[0]);
28212838 }
2822 const off = syms_sect.sh_offset + @sizeOf(elf.Elf32_Sym) * index;
28232839 try self.base.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
28242840 },
28252841 .p64 => {
2826 var sym = [1]elf.Elf64_Sym{self.local_symbols.items[index]};
2842 var sym = [1]elf.Elf64_Sym{local};
28272843 if (foreign_endian) {
28282844 mem.byteSwapAllFields(elf.Elf64_Sym, &sym[0]);
28292845 }
2830 const off = syms_sect.sh_offset + @sizeOf(elf.Elf64_Sym) * index;
28312846 try self.base.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
28322847 },
28332848 }
......@@ -2847,8 +2862,14 @@ fn writeAllGlobalSymbols(self: *Elf) !void {
28472862 if (needed_size > self.allocatedSize(syms_sect.sh_offset)) {
28482863 // Move all the symbols to a new file location.
28492864 const new_offset = self.findFreeSpace(needed_size, sym_align);
2865 log.debug("moving '.symtab' from 0x{x} to 0x{x}", .{ syms_sect.sh_offset, new_offset });
28502866 const existing_size = @as(u64, syms_sect.sh_info) * sym_size;
2851 const amt = try self.base.file.?.copyRangeAll(syms_sect.sh_offset, self.base.file.?, new_offset, existing_size);
2867 const amt = try self.base.file.?.copyRangeAll(
2868 syms_sect.sh_offset,
2869 self.base.file.?,
2870 new_offset,
2871 existing_size,
2872 );
28522873 if (amt != existing_size) return error.InputOutput;
28532874 syms_sect.sh_offset = new_offset;
28542875 }
......@@ -2857,19 +2878,21 @@ fn writeAllGlobalSymbols(self: *Elf) !void {
28572878
28582879 const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
28592880 const global_syms_off = syms_sect.sh_offset + self.local_symbols.items.len * sym_size;
2881 log.debug("writing {d} global symbols at 0x{x}", .{ self.global_symbols.items.len, global_syms_off });
28602882 switch (self.ptr_width) {
28612883 .p32 => {
28622884 const buf = try self.base.allocator.alloc(elf.Elf32_Sym, self.global_symbols.items.len);
28632885 defer self.base.allocator.free(buf);
28642886
28652887 for (buf) |*sym, i| {
2888 const global = self.global_symbols.items[i];
28662889 sym.* = .{
2867 .st_name = self.global_symbols.items[i].st_name,
2868 .st_value = @intCast(u32, self.global_symbols.items[i].st_value),
2869 .st_size = @intCast(u32, self.global_symbols.items[i].st_size),
2870 .st_info = self.global_symbols.items[i].st_info,
2871 .st_other = self.global_symbols.items[i].st_other,
2872 .st_shndx = self.global_symbols.items[i].st_shndx,
2890 .st_name = global.st_name,
2891 .st_value = @intCast(u32, global.st_value),
2892 .st_size = @intCast(u32, global.st_size),
2893 .st_info = global.st_info,
2894 .st_other = global.st_other,
2895 .st_shndx = global.st_shndx,
28732896 };
28742897 if (foreign_endian) {
28752898 mem.byteSwapAllFields(elf.Elf32_Sym, sym);
......@@ -2882,13 +2905,14 @@ fn writeAllGlobalSymbols(self: *Elf) !void {
28822905 defer self.base.allocator.free(buf);
28832906
28842907 for (buf) |*sym, i| {
2908 const global = self.global_symbols.items[i];
28852909 sym.* = .{
2886 .st_name = self.global_symbols.items[i].st_name,
2887 .st_value = self.global_symbols.items[i].st_value,
2888 .st_size = self.global_symbols.items[i].st_size,
2889 .st_info = self.global_symbols.items[i].st_info,
2890 .st_other = self.global_symbols.items[i].st_other,
2891 .st_shndx = self.global_symbols.items[i].st_shndx,
2910 .st_name = global.st_name,
2911 .st_value = global.st_value,
2912 .st_size = global.st_size,
2913 .st_info = global.st_info,
2914 .st_other = global.st_other,
2915 .st_shndx = global.st_shndx,
28922916 };
28932917 if (foreign_endian) {
28942918 mem.byteSwapAllFields(elf.Elf64_Sym, sym);
......@@ -3194,3 +3218,14 @@ const CsuObjects = struct {
31943218 self.crtn = crtn;
31953219 }
31963220};
3221
3222fn logSymtab(self: Elf) void {
3223 log.debug("locals:", .{});
3224 for (self.local_symbols.items) |sym, id| {
3225 log.debug(" {d}: {s}: @{x} in {d}", .{ id, self.getString(sym.st_name), sym.st_value, sym.st_shndx });
3226 }
3227 log.debug("globals:", .{});
3228 for (self.global_symbols.items) |sym, id| {
3229 log.debug(" {d}: {s}: @{x} in {d}", .{ id, self.getString(sym.st_name), sym.st_value, sym.st_shndx });
3230 }
3231}