authorgravatar for jacoblevgw@gmail.comJacob G-W <jacoblevgw@gmail.com> 2021-08-29 17:25:18-04:00
committergravatar for jacoblevgw@gmail.comJacob G-W <jacoblevgw@gmail.com> 2021-09-20 16:37:56-04:00
logf697e0a326b06b7dcf641fbd61110be756407dcf
treea4cd4845e8ca601cca1d08d5f16cb004bfbe127a
parent84ab03a875b2a1b9d38f094242ddbd54f133c1a5

plan9 linker: link lineinfo and filenames

3 files changed, 312 insertions(+), 70 deletions(-)

src/codegen.zig+31-15
......@@ -52,16 +52,23 @@ pub const DebugInfoOutput = union(enum) {
5252 /// assume all numbers/variables are bytes
5353 /// 0 w x y z -> interpret w x y z as a big-endian i32, and add it to the line offset
5454 /// x when x < 65 -> add x to line offset
55 /// x when x < 129 -> subtract 64 from x and add it to the line offset
55 /// x when x < 129 -> subtract 64 from x and subtract it from the line offset
5656 /// x -> subtract 129 from x, multiply it by the quanta of the instruction size
5757 /// (1 on x86_64), and add it to the pc
5858 /// after every opcode, add the quanta of the instruction size to the pc
5959 plan9: struct {
6060 /// the actual opcodes
6161 dbg_line: *std.ArrayList(u8),
62 /// what line the debuginfo starts on
63 /// this helps because the linker might have to insert some opcodes to make sure that the line count starts at the right amount for the next decl
64 start_line: *?u32,
6265 /// what the line count ends on after codegen
6366 /// this helps because the linker might have to insert some opcodes to make sure that the line count starts at the right amount for the next decl
6467 end_line: *u32,
68 /// the last pc change op
69 /// This is very useful for adding quanta
70 /// to it if its not actually the last one.
71 pcop_change_index: *?u32,
6572 },
6673 none,
6774};
......@@ -946,7 +953,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
946953
947954 fn dbgAdvancePCAndLine(self: *Self, line: u32, column: u32) InnerError!void {
948955 const delta_line = @intCast(i32, line) - @intCast(i32, self.prev_di_line);
949 const delta_pc = self.code.items.len - self.prev_di_pc;
956 const delta_pc: usize = self.code.items.len - self.prev_di_pc;
950957 switch (self.debug_output) {
951958 .dwarf => |dbg_out| {
952959 // TODO Look into using the DWARF special opcodes to compress this data.
......@@ -960,30 +967,39 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
960967 leb128.writeILEB128(dbg_out.dbg_line.writer(), delta_line) catch unreachable;
961968 }
962969 dbg_out.dbg_line.appendAssumeCapacity(DW.LNS.copy);
970 self.prev_di_pc = self.code.items.len;
971 self.prev_di_line = line;
972 self.prev_di_column = column;
973 self.prev_di_pc = self.code.items.len;
963974 },
964975 .plan9 => |dbg_out| {
976 if (delta_pc <= 0) return; // only do this when the pc changes
965977 // we have already checked the target in the linker to make sure it is compatable
966978 const quant = @import("link/Plan9/aout.zig").getPCQuant(self.target.cpu.arch) catch unreachable;
967979
968980 // increasing the line number
969 if (delta_line > 0 and delta_line < 65) {
970 try dbg_out.dbg_line.append(@intCast(u8, delta_line));
971 } else if (delta_line < 0 and delta_line > -65) {
972 try dbg_out.dbg_line.append(@intCast(u8, -delta_line + 64));
973 } else if (delta_line != 0) {
974 try dbg_out.dbg_line.writer().writeIntBig(i32, delta_line);
975 }
981 try @import("link/Plan9.zig").changeLine(dbg_out.dbg_line, delta_line);
976982 // increasing the pc
977 if (delta_pc - quant != 0) {
978 try dbg_out.dbg_line.append(@intCast(u8, delta_pc - quant + 129));
979 }
983 const d_pc_p9 = @intCast(i64, delta_pc) - quant;
984 if (d_pc_p9 > 0) {
985 // minus one becaue if its the last one, we want to leave space to change the line which is one quanta
986 try dbg_out.dbg_line.append(@intCast(u8, @divExact(d_pc_p9, quant) + 128) - quant);
987 if (dbg_out.pcop_change_index.*) |pci|
988 dbg_out.dbg_line.items[pci] += 1;
989 dbg_out.pcop_change_index.* = @intCast(u32, dbg_out.dbg_line.items.len - 1);
990 } else if (d_pc_p9 == 0) {
991 // we don't need to do anything, because adding the quant does it for us
992 } else unreachable;
993 if (dbg_out.start_line.* == null)
994 dbg_out.start_line.* = self.prev_di_line;
980995 dbg_out.end_line.* = line;
996 // only do this if the pc changed
997 self.prev_di_line = line;
998 self.prev_di_column = column;
999 self.prev_di_pc = self.code.items.len;
9811000 },
9821001 .none => {},
9831002 }
984 self.prev_di_line = line;
985 self.prev_di_column = column;
986 self.prev_di_pc = self.code.items.len;
9871003 }
9881004
9891005 /// Asserts there is already capacity to insert into top branch inst_table.
src/link/Plan9.zig+273-55
......@@ -20,6 +20,14 @@ const Allocator = std.mem.Allocator;
2020const log = std.log.scoped(.link);
2121const assert = std.debug.assert;
2222
23const FnDeclOutput = struct {
24 code: []const u8,
25 /// this might have to be modified in the linker, so thats why its mutable
26 lineinfo: []u8,
27 start_line: u32,
28 end_line: u32,
29};
30
2331base: link.File,
2432sixtyfour_bit: bool,
2533error_flags: File.ErrorFlags = File.ErrorFlags{},
......@@ -27,9 +35,31 @@ bases: Bases,
2735
2836/// A symbol's value is just casted down when compiling
2937/// for a 32 bit target.
38/// Does not represent the order or amount of symbols in the file
39/// it is just useful for storing symbols. Some other symbols are in
40/// file_segments.
3041syms: std.ArrayListUnmanaged(aout.Sym) = .{},
3142
32fn_decl_table: std.AutoArrayHashMapUnmanaged(*Module.Decl, []const u8) = .{},
43/// The plan9 a.out format requires segments of
44/// filenames to be deduplicated, so we use this map to
45/// de duplicate it. The value is the value of the path
46/// component
47file_segments: std.StringArrayHashMapUnmanaged(u16) = .{},
48/// The value of a 'f' symbol increments by 1 every time, so that no 2 'f'
49/// symbols have the same value.
50file_segments_i: u16 = 1,
51
52path_arena: std.heap.ArenaAllocator,
53
54/// maps a file scope to a hash map of decl to codegen output
55/// this is useful for line debuginfo, since it makes sense to sort by file
56/// The debugger looks for the first file (aout.Sym.Type.z) preceeding the text symbol
57/// of the function to know what file it came from.
58/// If we group the decls by file, it makes it really easy to do this (put the symbol in the correct place)
59fn_decl_table: std.AutoArrayHashMapUnmanaged(
60 *Module.Scope.File,
61 struct { sym_index: u32, functions: std.AutoArrayHashMapUnmanaged(*Module.Decl, FnDeclOutput) = .{} },
62) = .{},
3363data_decl_table: std.AutoArrayHashMapUnmanaged(*Module.Decl, []const u8) = .{},
3464
3565hdr: aout.ExecHdr = undefined,
......@@ -110,8 +140,12 @@ pub fn createEmpty(gpa: *Allocator, options: link.Options) !*Plan9 {
110140 33...64 => true,
111141 else => return error.UnsupportedP9Architecture,
112142 };
143
144 var arena_allocator = std.heap.ArenaAllocator.init(gpa);
145
113146 const self = try gpa.create(Plan9);
114147 self.* = .{
148 .path_arena = arena_allocator,
115149 .base = .{
116150 .tag = .plan9,
117151 .options = options,
......@@ -122,9 +156,66 @@ pub fn createEmpty(gpa: *Allocator, options: link.Options) !*Plan9 {
122156 .bases = undefined,
123157 .magic = try aout.magicFromArch(self.base.options.target.cpu.arch),
124158 };
159 // a / will always be in a file path
160 try self.file_segments.put(self.base.allocator, "/", 1);
125161 return self;
126162}
127163
164fn putFn(self: *Plan9, decl: *Module.Decl, out: FnDeclOutput) !void {
165 const gpa = self.base.allocator;
166 const fn_map_res = try self.fn_decl_table.getOrPut(gpa, decl.namespace.file_scope);
167 if (fn_map_res.found_existing) {
168 try fn_map_res.value_ptr.functions.put(gpa, decl, out);
169 } else {
170 const file = decl.namespace.file_scope;
171 const arena = &self.path_arena.allocator;
172 // each file gets a symbol
173 fn_map_res.value_ptr.* = .{
174 .sym_index = blk: {
175 try self.syms.append(gpa, undefined);
176 break :blk @intCast(u32, self.syms.items.len - 1);
177 },
178 };
179 try fn_map_res.value_ptr.functions.put(gpa, decl, out);
180
181 var a = std.ArrayList(u8).init(arena);
182 errdefer a.deinit();
183 // every 'z' starts with 0
184 try a.append(0);
185 // path component value of '/'
186 try a.writer().writeIntBig(u16, 1);
187
188 // getting the full file path
189 var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
190 const dir = file.pkg.root_src_directory.path orelse try std.os.getcwd(&buf);
191 const sub_path = try std.fs.path.join(arena, &.{ dir, file.sub_file_path });
192 try self.addPathComponents(sub_path, &a);
193
194 // null terminate
195 try a.append(0);
196 const final = a.toOwnedSlice();
197 self.syms.items[fn_map_res.value_ptr.sym_index] = .{
198 .type = .z,
199 .value = 1,
200 .name = final,
201 };
202 }
203}
204
205fn addPathComponents(self: *Plan9, path: []const u8, a: *std.ArrayList(u8)) !void {
206 const sep = std.fs.path.sep;
207 var it = std.mem.tokenize(u8, path, &.{sep});
208 while (it.next()) |component| {
209 if (self.file_segments.get(component)) |num| {
210 try a.writer().writeIntBig(u16, num);
211 } else {
212 self.file_segments_i += 1;
213 try self.file_segments.put(self.base.allocator, component, self.file_segments_i);
214 try a.writer().writeIntBig(u16, self.file_segments_i);
215 }
216 }
217}
218
128219pub fn updateFunc(self: *Plan9, module: *Module, func: *Module.Fn, air: Air, liveness: Liveness) !void {
129220 if (build_options.skip_non_native and builtin.object_format != .plan9) {
130221 @panic("Attempted to compile for object format that was disabled by build configuration");
......@@ -139,7 +230,9 @@ pub fn updateFunc(self: *Plan9, module: *Module, func: *Module.Fn, air: Air, liv
139230 defer code_buffer.deinit();
140231 var dbg_line_buffer = std.ArrayList(u8).init(self.base.allocator);
141232 defer dbg_line_buffer.deinit();
142 var end_line: u32 = 0;
233 var start_line: ?u32 = null;
234 var end_line: u32 = undefined;
235 var pcop_change_index: ?u32 = null;
143236
144237 const res = try codegen.generateFunction(
145238 &self.base,
......@@ -152,6 +245,8 @@ pub fn updateFunc(self: *Plan9, module: *Module, func: *Module.Fn, air: Air, liv
152245 .plan9 = .{
153246 .dbg_line = &dbg_line_buffer,
154247 .end_line = &end_line,
248 .start_line = &start_line,
249 .pcop_change_index = &pcop_change_index,
155250 },
156251 },
157252 );
......@@ -163,7 +258,13 @@ pub fn updateFunc(self: *Plan9, module: *Module, func: *Module.Fn, air: Air, liv
163258 return;
164259 },
165260 };
166 try self.fn_decl_table.put(self.base.allocator, decl, code);
261 const out: FnDeclOutput = .{
262 .code = code,
263 .lineinfo = dbg_line_buffer.toOwnedSlice(),
264 .start_line = start_line.?,
265 .end_line = end_line,
266 };
267 try self.putFn(decl, out);
167268 return self.updateFinish(decl);
168269}
169270
......@@ -242,6 +343,30 @@ pub fn flush(self: *Plan9, comp: *Compilation) !void {
242343 return self.flushModule(comp);
243344}
244345
346pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void {
347 if (delta_line > 0 and delta_line < 65) {
348 const toappend = @intCast(u8, delta_line);
349 try l.append(toappend);
350 } else if (delta_line < 0 and delta_line > -65) {
351 const toadd: u8 = @intCast(u8, -delta_line + 64);
352 try l.append(toadd);
353 } else if (delta_line != 0) {
354 try l.append(0);
355 try l.writer().writeIntBig(i32, delta_line);
356 }
357}
358
359fn declCount(self: *Plan9) u64 {
360 var fn_decl_count: u64 = 0;
361 var itf_files = self.fn_decl_table.iterator();
362 while (itf_files.next()) |ent| {
363 // get the submap
364 var submap = ent.value_ptr.functions;
365 fn_decl_count += submap.count();
366 }
367 return self.data_decl_table.count() + fn_decl_count;
368}
369
245370pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
246371 if (build_options.skip_non_native and builtin.object_format != .plan9) {
247372 @panic("Attempted to compile for object format that was disabled by build configuration");
......@@ -257,13 +382,13 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
257382
258383 const mod = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
259384
260 assert(self.got_len == self.fn_decl_table.count() + self.data_decl_table.count() + self.got_index_free_list.items.len);
385 assert(self.got_len == self.declCount() + self.got_index_free_list.items.len);
261386 const got_size = self.got_len * if (!self.sixtyfour_bit) @as(u32, 4) else 8;
262387 var got_table = try self.base.allocator.alloc(u8, got_size);
263388 defer self.base.allocator.free(got_table);
264389
265 // + 3 for header, got, symbols
266 var iovecs = try self.base.allocator.alloc(std.os.iovec_const, self.fn_decl_table.count() + self.data_decl_table.count() + 3);
390 // + 4 for header, got, symbols, linecountinfo
391 var iovecs = try self.base.allocator.alloc(std.os.iovec_const, self.declCount() + 4);
267392 defer self.base.allocator.free(iovecs);
268393
269394 const file = self.base.file.?;
......@@ -276,30 +401,52 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
276401 iovecs[0] = .{ .iov_base = hdr_slice.ptr, .iov_len = hdr_slice.len };
277402 var iovecs_i: usize = 1;
278403 var text_i: u64 = 0;
404
405 var linecountinfo = std.ArrayList(u8).init(self.base.allocator);
406 defer linecountinfo.deinit();
279407 // text
280408 {
281 var it = self.fn_decl_table.iterator();
282 while (it.next()) |entry| {
283 const decl = entry.key_ptr.*;
284 const code = entry.value_ptr.*;
285 log.debug("write text decl {*} ({s})", .{ decl, decl.name });
286 foff += code.len;
287 iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
288 iovecs_i += 1;
289 const off = self.getAddr(text_i, .t);
290 text_i += code.len;
291 decl.link.plan9.offset = off;
292 if (!self.sixtyfour_bit) {
293 mem.writeIntNative(u32, got_table[decl.link.plan9.got_index.? * 4 ..][0..4], @intCast(u32, off));
294 mem.writeInt(u32, got_table[decl.link.plan9.got_index.? * 4 ..][0..4], @intCast(u32, off), self.base.options.target.cpu.arch.endian());
295 } else {
296 mem.writeInt(u64, got_table[decl.link.plan9.got_index.? * 8 ..][0..8], off, self.base.options.target.cpu.arch.endian());
297 }
298 self.syms.items[decl.link.plan9.sym_index.?].value = off;
299 if (mod.decl_exports.get(decl)) |exports| {
300 try self.addDeclExports(mod, decl, exports);
409 var linecount: u32 = 0;
410 var it_file = self.fn_decl_table.iterator();
411 while (it_file.next()) |fentry| {
412 var it = fentry.value_ptr.functions.iterator();
413 while (it.next()) |entry| {
414 const decl = entry.key_ptr.*;
415 const out = entry.value_ptr.*;
416 log.debug("write text decl {*} ({s}), lines {d} to {d}", .{ decl, decl.name, out.start_line, out.end_line });
417 {
418 // connect the previous decl to the next
419 const delta_line = @intCast(i32, out.start_line) - @intCast(i32, linecount);
420
421 try changeLine(&linecountinfo, delta_line);
422 // TODO change the pc too (maybe?)
423
424 // write out the actual info that was generated in codegen now
425 try linecountinfo.appendSlice(out.lineinfo);
426 linecount = out.end_line;
427 }
428 foff += out.code.len;
429 iovecs[iovecs_i] = .{ .iov_base = out.code.ptr, .iov_len = out.code.len };
430 iovecs_i += 1;
431 const off = self.getAddr(text_i, .t);
432 text_i += out.code.len;
433 decl.link.plan9.offset = off;
434 if (!self.sixtyfour_bit) {
435 mem.writeIntNative(u32, got_table[decl.link.plan9.got_index.? * 4 ..][0..4], @intCast(u32, off));
436 mem.writeInt(u32, got_table[decl.link.plan9.got_index.? * 4 ..][0..4], @intCast(u32, off), self.base.options.target.cpu.arch.endian());
437 } else {
438 mem.writeInt(u64, got_table[decl.link.plan9.got_index.? * 8 ..][0..8], off, self.base.options.target.cpu.arch.endian());
439 }
440 self.syms.items[decl.link.plan9.sym_index.?].value = off;
441 if (mod.decl_exports.get(decl)) |exports| {
442 try self.addDeclExports(mod, decl, exports);
443 }
301444 }
302445 }
446 if (linecountinfo.items.len & 1 == 1) {
447 // just a nop to make it even, the plan9 linker does this
448 try linecountinfo.append(129);
449 }
303450 // etext symbol
304451 self.syms.items[2].value = self.getAddr(text_i, .t);
305452 }
......@@ -337,20 +484,23 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
337484 // edata
338485 self.syms.items[1].value = self.getAddr(0x0, .b);
339486 var sym_buf = std.ArrayList(u8).init(self.base.allocator);
340 defer sym_buf.deinit();
341487 try self.writeSyms(&sym_buf);
342 assert(2 + self.fn_decl_table.count() + self.data_decl_table.count() == iovecs_i); // we didn't write all the decls
343 iovecs[iovecs_i] = .{ .iov_base = sym_buf.items.ptr, .iov_len = sym_buf.items.len };
488 const syms = sym_buf.toOwnedSlice();
489 defer self.base.allocator.free(syms);
490 assert(2 + self.declCount() == iovecs_i); // we didn't write all the decls
491 iovecs[iovecs_i] = .{ .iov_base = syms.ptr, .iov_len = syms.len };
492 iovecs_i += 1;
493 iovecs[iovecs_i] = .{ .iov_base = linecountinfo.items.ptr, .iov_len = linecountinfo.items.len };
344494 iovecs_i += 1;
345495 // generate the header
346496 self.hdr = .{
347497 .magic = self.magic,
348498 .text = @intCast(u32, text_i),
349499 .data = @intCast(u32, data_i),
350 .syms = @intCast(u32, sym_buf.items.len),
500 .syms = @intCast(u32, syms.len),
351501 .bss = 0,
352 .pcsz = 0,
353502 .spsz = 0,
503 .pcsz = @intCast(u32, linecountinfo.items.len),
354504 .entry = @intCast(u32, self.entry_val.?),
355505 };
356506 std.mem.copy(u8, hdr_slice, self.hdr.toU8s()[0..hdr_size]);
......@@ -397,7 +547,15 @@ pub fn freeDecl(self: *Plan9, decl: *Module.Decl) void {
397547 // in the deleteUnusedDecl function.
398548 const is_fn = (decl.val.tag() == .function);
399549 if (is_fn) {
400 _ = self.fn_decl_table.swapRemove(decl);
550 var symidx_and_submap =
551 self.fn_decl_table.get(decl.namespace.file_scope).?;
552 var submap = symidx_and_submap.functions;
553 _ = submap.swapRemove(decl);
554 if (submap.count() == 0) {
555 self.syms.items[symidx_and_submap.sym_index] = aout.Sym.undefined_symbol;
556 self.syms_index_free_list.append(self.base.allocator, symidx_and_submap.sym_index) catch {};
557 submap.deinit(self.base.allocator);
558 }
401559 } else {
402560 _ = self.data_decl_table.swapRemove(decl);
403561 }
......@@ -407,7 +565,7 @@ pub fn freeDecl(self: *Plan9, decl: *Module.Decl) void {
407565 }
408566 if (decl.link.plan9.sym_index) |i| {
409567 self.syms_index_free_list.append(self.base.allocator, i) catch {};
410 self.syms.items[i] = undefined;
568 self.syms.items[i] = aout.Sym.undefined_symbol;
411569 }
412570}
413571
......@@ -436,19 +594,29 @@ pub fn updateDeclExports(
436594 _ = exports;
437595}
438596pub fn deinit(self: *Plan9) void {
439 var itf = self.fn_decl_table.iterator();
440 while (itf.next()) |entry| {
441 self.base.allocator.free(entry.value_ptr.*);
597 const gpa = self.base.allocator;
598 var itf_files = self.fn_decl_table.iterator();
599 while (itf_files.next()) |ent| {
600 // get the submap
601 var submap = ent.value_ptr.functions;
602 defer submap.deinit(gpa);
603 var itf = submap.iterator();
604 while (itf.next()) |entry| {
605 gpa.free(entry.value_ptr.code);
606 gpa.free(entry.value_ptr.lineinfo);
607 }
442608 }
443 self.fn_decl_table.deinit(self.base.allocator);
609 self.fn_decl_table.deinit(gpa);
444610 var itd = self.data_decl_table.iterator();
445611 while (itd.next()) |entry| {
446 self.base.allocator.free(entry.value_ptr.*);
612 gpa.free(entry.value_ptr.*);
447613 }
448 self.data_decl_table.deinit(self.base.allocator);
449 self.syms.deinit(self.base.allocator);
450 self.got_index_free_list.deinit(self.base.allocator);
451 self.syms_index_free_list.deinit(self.base.allocator);
614 self.data_decl_table.deinit(gpa);
615 self.syms.deinit(gpa);
616 self.got_index_free_list.deinit(gpa);
617 self.syms_index_free_list.deinit(gpa);
618 self.file_segments.deinit(gpa);
619 self.path_arena.deinit();
452620}
453621
454622pub const Export = ?usize;
......@@ -458,7 +626,6 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
458626 return error.LLVMBackendDoesNotSupportPlan9;
459627 assert(options.object_format == .plan9);
460628 const file = try options.emit.?.directory.handle.createFile(sub_path, .{
461 .truncate = false,
462629 .read = true,
463630 .mode = link.determineMode(options),
464631 });
......@@ -492,21 +659,72 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
492659 return self;
493660}
494661
662pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void {
663 log.debug("write sym.name: {s}", .{sym.name});
664 log.debug("write sym.value: {x}", .{sym.value});
665 if (sym.type == .bad) return; // we don't want to write free'd symbols
666 if (!self.sixtyfour_bit) {
667 try w.writeIntBig(u32, @intCast(u32, sym.value));
668 } else {
669 try w.writeIntBig(u64, sym.value);
670 }
671 try w.writeByte(@enumToInt(sym.type));
672 try w.writeAll(sym.name);
673 try w.writeByte(0);
674}
495675pub fn writeSyms(self: *Plan9, buf: *std.ArrayList(u8)) !void {
496676 const writer = buf.writer();
497 for (self.syms.items) |sym| {
498 log.debug("sym.name: {s}", .{sym.name});
499 log.debug("sym.value: {x}", .{sym.value});
500 if (mem.eql(u8, sym.name, "_start"))
501 self.entry_val = sym.value;
502 if (!self.sixtyfour_bit) {
503 try writer.writeIntBig(u32, @intCast(u32, sym.value));
504 } else {
505 try writer.writeIntBig(u64, sym.value);
677 // write the f symbols
678 {
679 var it = self.file_segments.iterator();
680 while (it.next()) |entry| {
681 try self.writeSym(writer, .{
682 .type = .f,
683 .value = entry.value_ptr.*,
684 .name = entry.key_ptr.*,
685 });
686 }
687 }
688 // write the data symbols
689 {
690 var it = self.data_decl_table.iterator();
691 while (it.next()) |entry| {
692 const decl = entry.key_ptr.*;
693 const sym = self.syms.items[decl.link.plan9.sym_index.?];
694 try self.writeSym(writer, sym);
695 if (self.base.options.module.?.decl_exports.get(decl)) |exports| {
696 for (exports) |e| {
697 try self.writeSym(writer, self.syms.items[e.link.plan9.?]);
698 }
699 }
700 }
701 }
702 // text symbols are the hardest:
703 // the file of a text symbol is the .z symbol before it
704 // so we have to write everything in the right order
705 {
706 var it_file = self.fn_decl_table.iterator();
707 while (it_file.next()) |fentry| {
708 var symidx_and_submap = fentry.value_ptr;
709 // write the z symbol
710 try self.writeSym(writer, self.syms.items[symidx_and_submap.sym_index]);
711
712 // write all the decls come from the file of the z symbol
713 var submap_it = symidx_and_submap.functions.iterator();
714 while (submap_it.next()) |entry| {
715 const decl = entry.key_ptr.*;
716 const sym = self.syms.items[decl.link.plan9.sym_index.?];
717 try self.writeSym(writer, sym);
718 if (self.base.options.module.?.decl_exports.get(decl)) |exports| {
719 for (exports) |e| {
720 const s = self.syms.items[e.link.plan9.?];
721 if (mem.eql(u8, s.name, "_start"))
722 self.entry_val = s.value;
723 try self.writeSym(writer, s);
724 }
725 }
726 }
506727 }
507 try writer.writeByte(@enumToInt(sym.type));
508 try writer.writeAll(sym.name);
509 try writer.writeByte(0);
510728 }
511729}
512730
src/link/Plan9/aout.zig+8
......@@ -34,6 +34,12 @@ pub const Sym = struct {
3434 type: Type,
3535 name: []const u8,
3636
37 pub const undefined_symbol: Sym = .{
38 .value = undefined,
39 .type = .bad,
40 .name = "undefined_symbol",
41 };
42
3743 /// The type field is one of the following characters with the
3844 /// high bit set:
3945 /// T text segment symbol
......@@ -65,6 +71,8 @@ pub const Sym = struct {
6571 z = 0x80 | 'z',
6672 Z = 0x80 | 'Z',
6773 m = 0x80 | 'm',
74 /// represents an undefined symbol, to be removed in flush
75 bad = 0,
6876
6977 pub fn toGlobal(self: Type) Type {
7078 return switch (self) {