authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-12 20:11:47-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-12 20:11:47-04:00
loge3a0fac1a77a8c637c790670ff749879298becad
tree517ab4cc5816e582e23be7aa46c580f942d4bfcb
parentfda0eef9fbf2fe73baf09127c8925910dcd35205

self-hosted: link: global offset table support for decls

4 files changed, 198 insertions(+), 100 deletions(-)

src-self-hosted/Package.zig+1
......@@ -50,3 +50,4 @@ pub fn add(self: *Package, name: []const u8, package: *Package) !void {
5050const std = @import("std");
5151const mem = std.mem;
5252const assert = std.debug.assert;
53const Package = @This();
src-self-hosted/codegen.zig+8-15
......@@ -5,13 +5,9 @@ const ir = @import("ir.zig");
55const Type = @import("type.zig").Type;
66const Value = @import("value.zig").Value;
77const Target = std.Target;
8const Allocator = mem.Allocator;
89
9pub fn generateSymbol(
10 typed_value: ir.TypedValue,
11 module: ir.Module,
12 code: *std.ArrayList(u8),
13 errors: *std.ArrayList(ir.ErrorMsg),
14) !void {
10pub fn generateSymbol(typed_value: ir.TypedValue, module: ir.Module, code: *std.ArrayList(u8)) !?*ir.ErrorMsg {
1511 switch (typed_value.ty.zigTypeTag()) {
1612 .Fn => {
1713 const module_fn = typed_value.val.cast(Value.Payload.Function).?.func;
......@@ -21,14 +17,14 @@ pub fn generateSymbol(
2117 .mod_fn = module_fn,
2218 .code = code,
2319 .inst_table = std.AutoHashMap(*ir.Inst, Function.MCValue).init(code.allocator),
24 .errors = errors,
20 .err_msg = null,
2521 };
2622 defer function.inst_table.deinit();
2723
2824 for (module_fn.body.instructions) |inst| {
2925 const new_inst = function.genFuncInst(inst) catch |err| switch (err) {
3026 error.CodegenFail => {
31 assert(function.errors.items.len != 0);
27 assert(function.err_msg != null);
3228 break;
3329 },
3430 else => |e| return e,
......@@ -36,7 +32,7 @@ pub fn generateSymbol(
3632 try function.inst_table.putNoClobber(inst, new_inst);
3733 }
3834
39 return Symbol{ .errors = function.errors.toOwnedSlice() };
35 return function.err_msg;
4036 },
4137 else => @panic("TODO implement generateSymbol for non-function decls"),
4238 }
......@@ -47,7 +43,7 @@ const Function = struct {
4743 mod_fn: *const ir.Module.Fn,
4844 code: *std.ArrayList(u8),
4945 inst_table: std.AutoHashMap(*ir.Inst, MCValue),
50 errors: *std.ArrayList(ir.ErrorMsg),
46 err_msg: ?*ir.ErrorMsg,
5147
5248 const MCValue = union(enum) {
5349 none,
......@@ -428,11 +424,8 @@ const Function = struct {
428424
429425 fn fail(self: *Function, src: usize, comptime format: []const u8, args: var) error{ CodegenFail, OutOfMemory } {
430426 @setCold(true);
431 try self.errors.ensureCapacity(self.errors.items.len + 1);
432 self.errors.appendAssumeCapacity(.{
433 .byte_offset = src,
434 .msg = try std.fmt.allocPrint(self.errors.allocator, format, args),
435 });
427 assert(self.err_msg == null);
428 self.err_msg = try ir.ErrorMsg.create(self.code.allocator, src, format, args);
436429 return error.CodegenFail;
437430 }
438431};
src-self-hosted/ir.zig+32-37
......@@ -201,7 +201,7 @@ pub const Module = struct {
201201 decl_table: std.AutoHashMap(Decl.Hash, *Decl),
202202
203203 optimize_mode: std.builtin.Mode,
204 link_error_flags: link.ElfFile.ErrorFlags = .{},
204 link_error_flags: link.ElfFile.ErrorFlags = link.ElfFile.ErrorFlags{},
205205
206206 /// We optimize memory usage for a compilation with no compile errors by storing the
207207 /// error messages and mapping outside of `Decl`.
......@@ -247,7 +247,7 @@ pub const Module = struct {
247247 /// The most recent value of the Decl after a successful semantic analysis.
248248 /// The tag for this union is determined by the tag value of the analysis field.
249249 typed_value: union {
250 never_succeeded,
250 never_succeeded: void,
251251 most_recent: TypedValue.Managed,
252252 },
253253 /// Represents the "shallow" analysis status. For example, for decls that are functions,
......@@ -278,12 +278,11 @@ pub const Module = struct {
278278 complete,
279279 },
280280
281 /// Represents the position of the code, if any, in the output file.
281 /// Represents the position of the code in the output file.
282282 /// This is populated regardless of semantic analysis and code generation.
283 /// This value is `undefined` if the type has no runtime bits.
284 link: link.ElfFile.Decl,
283 link: link.ElfFile.Decl = link.ElfFile.Decl.empty,
285284
286 /// The set of other decls whose typed_value could possibly change if this Decl's
285 /// The shallow set of other decls whose typed_value could possibly change if this Decl's
287286 /// typed_value is modified.
288287 /// TODO look into using a lightweight map/set data structure rather than a linear array.
289288 dependants: ArrayListUnmanaged(*Decl) = .{},
......@@ -368,11 +367,11 @@ pub const Module = struct {
368367 /// Reference to external memory, not owned by ZIRModule.
369368 sub_file_path: []const u8,
370369 source: union {
371 unloaded,
370 unloaded: void,
372371 bytes: [:0]const u8,
373372 },
374373 contents: union {
375 not_available,
374 not_available: void,
376375 module: *text.Module,
377376 },
378377 status: enum {
......@@ -575,9 +574,9 @@ pub const Module = struct {
575574 try self.failed_files.ensureCapacity(self.failed_files.size + 1);
576575
577576 var keep_source = false;
578 const source = try self.root_pkg_dir.readFileAllocOptions(
577 const source = try self.root_pkg.root_src_dir.readFileAllocOptions(
579578 self.allocator,
580 self.root_src_path,
579 self.root_pkg.root_src_path,
581580 std.math.maxInt(u32),
582581 1,
583582 0,
......@@ -628,20 +627,7 @@ pub const Module = struct {
628627 while (self.analysis_queue.popOrNull()) |work_item| {
629628 switch (work_item) {
630629 .decl => |decl| switch (decl.analysis) {
631 .success => |typed_value| {
632 var arena = decl.arena.promote(self.allocator);
633 const update_result = self.bin_file.updateDecl(
634 self.*,
635 typed_value,
636 decl.export_node,
637 decl.fullyQualifiedNameHash(),
638 &arena.allocator,
639 );
640 decl.arena = arena.state;
641 if (try update_result) |err_msg| {
642 decl.analysis = .{ .codegen_failure = err_msg };
643 }
644 },
630 .success => try self.bin_file.updateDecl(self, decl),
645631 },
646632 }
647633 }
......@@ -653,22 +639,22 @@ pub const Module = struct {
653639 return kv.value;
654640 } else {
655641 const new_decl = blk: {
656 var decl_arena = std.heap.ArenaAllocator.init(self.allocator);
657 errdefer decl_arena.deinit();
658 const new_decl = try decl_arena.allocator.create(Decl);
659 const name = try mem.dupeZ(&decl_arena.allocator, u8, old_inst.name);
642 try self.decl_table.ensureCapacity(self.decl_table.size + 1);
643 const new_decl = try self.allocator.create(Decl);
644 errdefer self.allocator.destroy(new_decl);
645 const name = try mem.dupeZ(self.allocator, u8, old_inst.name);
646 errdefer self.allocator.free(name);
660647 new_decl.* = .{
661 .arena = decl_arena.state,
662648 .name = name,
663 .src = old_inst.src,
664 .analysis = .in_progress,
665649 .scope = scope.findZIRModule(),
650 .src = old_inst.src,
651 .typed_value = .{ .never_succeeded = {} },
652 .analysis = .initial_in_progress,
666653 };
667 try self.decl_table.putNoClobber(hash, new_decl);
654 self.decl_table.putAssumeCapacityNoClobber(hash, new_decl);
668655 break :blk new_decl;
669656 };
670657
671 swapRemoveElem(self.allocator, *Scope.ZIRModule, root_scope, self.failed_decls);
672658 var decl_scope: Scope.DeclAnalysis = .{
673659 .base = .{ .parent = scope },
674660 .decl = new_decl,
......@@ -1838,6 +1824,7 @@ pub fn main() anyerror!void {
18381824 const bin_path = args[2];
18391825 const debug_error_trace = true;
18401826 const output_zir = true;
1827 const object_format: ?std.builtin.ObjectFormat = null;
18411828
18421829 const native_info = try std.zig.system.NativeTargetInfo.detect(allocator, .{});
18431830
......@@ -1845,9 +1832,9 @@ pub fn main() anyerror!void {
18451832 .target = native_info.target,
18461833 .output_mode = .Exe,
18471834 .link_mode = .Static,
1848 .object_format = options.object_format orelse native_info.target.getObjectFormat(),
1835 .object_format = object_format orelse native_info.target.getObjectFormat(),
18491836 });
1850 defer bin_file.deinit(allocator);
1837 defer bin_file.deinit();
18511838
18521839 var module = blk: {
18531840 const root_pkg = try Package.create(allocator, std.fs.cwd(), ".", src_path);
......@@ -1857,7 +1844,9 @@ pub fn main() anyerror!void {
18571844 errdefer allocator.destroy(root_scope);
18581845 root_scope.* = .{
18591846 .sub_file_path = root_pkg.root_src_path,
1860 .contents = .unloaded,
1847 .source = .{ .unloaded = {} },
1848 .contents = .{ .not_available = {} },
1849 .status = .unloaded,
18611850 };
18621851
18631852 break :blk Module{
......@@ -1866,7 +1855,13 @@ pub fn main() anyerror!void {
18661855 .root_scope = root_scope,
18671856 .bin_file = &bin_file,
18681857 .optimize_mode = .Debug,
1869 .decl_table = std.AutoHashMap(Decl.Hash, *Decl).init(allocator),
1858 .decl_table = std.AutoHashMap(Module.Decl.Hash, *Module.Decl).init(allocator),
1859 .decl_exports = std.AutoHashMap(*Module.Decl, []*Module.Export).init(allocator),
1860 .export_owners = std.AutoHashMap(*Module.Decl, []*Module.Export).init(allocator),
1861 .failed_decls = std.AutoHashMap(*Module.Decl, *ErrorMsg).init(allocator),
1862 .failed_fns = std.AutoHashMap(*Module.Fn, *ErrorMsg).init(allocator),
1863 .failed_files = std.AutoHashMap(*Module.Scope.ZIRModule, *ErrorMsg).init(allocator),
1864 .failed_exports = std.AutoHashMap(*Module.Export, *ErrorMsg).init(allocator),
18701865 };
18711866 };
18721867 defer module.deinit();
src-self-hosted/link.zig+157-48
......@@ -94,35 +94,40 @@ pub const ElfFile = struct {
9494
9595 /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
9696 /// Same order as in the file.
97 sections: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .{},
97 sections: std.ArrayListUnmanaged(elf.Elf64_Shdr) = std.ArrayListUnmanaged(elf.Elf64_Shdr){},
9898 shdr_table_offset: ?u64 = null,
9999
100100 /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
101101 /// Same order as in the file.
102 program_headers: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .{},
102 program_headers: std.ArrayListUnmanaged(elf.Elf64_Phdr) = std.ArrayListUnmanaged(elf.Elf64_Phdr){},
103103 phdr_table_offset: ?u64 = null,
104104 /// The index into the program headers of a PT_LOAD program header with Read and Execute flags
105105 phdr_load_re_index: ?u16 = null,
106 /// The index into the program headers of the global offset table.
107 /// It needs PT_LOAD and Read flags.
108 phdr_got_index: ?u16 = null,
106109 entry_addr: ?u64 = null,
107110
108 shstrtab: std.ArrayListUnmanaged(u8) = .{},
111 shstrtab: std.ArrayListUnmanaged(u8) = std.ArrayListUnmanaged(u8){},
109112 shstrtab_index: ?u16 = null,
110113
111114 text_section_index: ?u16 = null,
112115 symtab_section_index: ?u16 = null,
116 got_section_index: ?u16 = null,
113117
114118 /// The same order as in the file
115 symbols: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},
119 symbols: std.ArrayListUnmanaged(elf.Elf64_Sym) = std.ArrayListUnmanaged(elf.Elf64_Sym){},
116120
117 /// Same order as in the file.
118 offset_table: std.ArrayListUnmanaged(aoeu) = .{},
121 /// Same order as in the file. The value is the absolute vaddr value.
122 /// If the vaddr of the executable program header changes, the entire
123 /// offset table needs to be rewritten.
124 offset_table: std.ArrayListUnmanaged(u64) = std.ArrayListUnmanaged(u64){},
119125
120 /// This means the entire read-only executable program code needs to be rewritten.
121 phdr_load_re_dirty: bool = false,
122126 phdr_table_dirty: bool = false,
123127 shdr_table_dirty: bool = false,
124128 shstrtab_dirty: bool = false,
125 symtab_dirty: bool = false,
129 offset_table_count_dirty: bool = false,
130 symbol_count_dirty: bool = false,
126131
127132 error_flags: ErrorFlags = ErrorFlags{},
128133
......@@ -130,18 +135,25 @@ pub const ElfFile = struct {
130135 no_entry_point_found: bool = false,
131136 };
132137
133 /// TODO it's too bad this optional takes up double the memory it should
134138 pub const Decl = struct {
135139 /// Each decl always gets a local symbol with the fully qualified name.
136140 /// The vaddr and size are found here directly.
137141 /// The file offset is found by computing the vaddr offset from the section vaddr
138142 /// the symbol references, and adding that to the file offset of the section.
139 local_sym_index: ?usize = null,
143 /// If this field is 0, it means the codegen size = 0 and there is no symbol or
144 /// offset table entry.
145 local_sym_index: u32,
146 /// This field is undefined for symbols with size = 0.
147 offset_table_index: u32,
148
149 pub const empty = Decl{
150 .local_sym_index = 0,
151 .offset_table_index = undefined,
152 };
140153 };
141154
142 /// TODO it's too bad this optional takes up double the memory it should
143155 pub const Export = struct {
144 sym_index: ?usize = null,
156 sym_index: usize,
145157 };
146158
147159 pub fn deinit(self: *ElfFile) void {
......@@ -250,33 +262,57 @@ pub const ElfFile = struct {
250262 .p32 => true,
251263 .p64 => false,
252264 };
265 const ptr_size: u8 = switch (self.ptr_width) {
266 .p32 => 4,
267 .p64 => 8,
268 };
253269 if (self.phdr_load_re_index == null) {
254270 self.phdr_load_re_index = @intCast(u16, self.program_headers.items.len);
255271 const file_size = self.options.program_code_size_hint;
256272 const p_align = 0x1000;
257273 const off = self.findFreeSpace(file_size, p_align);
258274 //std.debug.warn("found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
259 try self.program_headers.append(.{
275 try self.program_headers.append(self.allocator, .{
260276 .p_type = elf.PT_LOAD,
261277 .p_offset = off,
262278 .p_filesz = file_size,
263279 .p_vaddr = default_entry_addr,
264280 .p_paddr = default_entry_addr,
265 .p_memsz = 0,
281 .p_memsz = file_size,
266282 .p_align = p_align,
267283 .p_flags = elf.PF_X | elf.PF_R,
268284 });
269285 self.entry_addr = null;
270 self.phdr_load_re_dirty = true;
286 self.phdr_table_dirty = true;
287 }
288 if (self.phdr_got_index == null) {
289 self.phdr_got_index = @intCast(u16, self.program_headers.items.len);
290 const file_size = @as(u64, ptr_size) * self.options.symbol_count_hint;
291 const off = self.findFreeSpace(file_size, ptr_size);
292 //std.debug.warn("found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
293 // TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.
294 // we'll need to re-use that function anyway, in case the GOT grows and overlaps something
295 // else in virtual memory.
296 const default_got_addr = 0x80000000;
297 try self.program_headers.append(self.allocator, .{
298 .p_type = elf.PT_LOAD,
299 .p_offset = off,
300 .p_filesz = file_size,
301 .p_vaddr = default_got_addr,
302 .p_paddr = default_got_addr,
303 .p_memsz = file_size,
304 .p_align = ptr_size,
305 .p_flags = elf.PF_R,
306 });
271307 self.phdr_table_dirty = true;
272308 }
273309 if (self.shstrtab_index == null) {
274310 self.shstrtab_index = @intCast(u16, self.sections.items.len);
275311 assert(self.shstrtab.items.len == 0);
276 try self.shstrtab.append(0); // need a 0 at position 0
312 try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0
277313 const off = self.findFreeSpace(self.shstrtab.items.len, 1);
278314 //std.debug.warn("found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
279 try self.sections.append(.{
315 try self.sections.append(self.allocator, .{
280316 .sh_name = try self.makeString(".shstrtab"),
281317 .sh_type = elf.SHT_STRTAB,
282318 .sh_flags = 0,
......@@ -295,7 +331,7 @@ pub const ElfFile = struct {
295331 self.text_section_index = @intCast(u16, self.sections.items.len);
296332 const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
297333
298 try self.sections.append(.{
334 try self.sections.append(self.allocator, .{
299335 .sh_name = try self.makeString(".text"),
300336 .sh_type = elf.SHT_PROGBITS,
301337 .sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
......@@ -309,6 +345,24 @@ pub const ElfFile = struct {
309345 });
310346 self.shdr_table_dirty = true;
311347 }
348 if (self.got_section_index == null) {
349 self.got_section_index = @intCast(u16, self.sections.items.len);
350 const phdr = &self.program_headers.items[self.phdr_got_index.?];
351
352 try self.sections.append(self.allocator, .{
353 .sh_name = try self.makeString(".got"),
354 .sh_type = elf.SHT_PROGBITS,
355 .sh_flags = elf.SHF_ALLOC,
356 .sh_addr = phdr.p_vaddr,
357 .sh_offset = phdr.p_offset,
358 .sh_size = phdr.p_filesz,
359 .sh_link = 0,
360 .sh_info = 0,
361 .sh_addralign = phdr.p_align,
362 .sh_entsize = ptr_size,
363 });
364 self.shdr_table_dirty = true;
365 }
312366 if (self.symtab_section_index == null) {
313367 self.symtab_section_index = @intCast(u16, self.sections.items.len);
314368 const min_align: u16 = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym);
......@@ -317,7 +371,7 @@ pub const ElfFile = struct {
317371 const off = self.findFreeSpace(file_size, min_align);
318372 //std.debug.warn("found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
319373
320 try self.sections.append(.{
374 try self.sections.append(self.allocator, .{
321375 .sh_name = try self.makeString(".symtab"),
322376 .sh_type = elf.SHT_SYMTAB,
323377 .sh_flags = 0,
......@@ -330,14 +384,14 @@ pub const ElfFile = struct {
330384 .sh_addralign = min_align,
331385 .sh_entsize = each_size,
332386 });
333 self.symtab_dirty = true;
334387 self.shdr_table_dirty = true;
388 try self.writeAllSymbols();
335389 }
336 const shsize: u64 = switch (ptr_width) {
390 const shsize: u64 = switch (self.ptr_width) {
337391 .p32 => @sizeOf(elf.Elf32_Shdr),
338392 .p64 => @sizeOf(elf.Elf64_Shdr),
339393 };
340 const shalign: u16 = switch (ptr_width) {
394 const shalign: u16 = switch (self.ptr_width) {
341395 .p32 => @alignOf(elf.Elf32_Shdr),
342396 .p64 => @alignOf(elf.Elf64_Shdr),
343397 };
......@@ -345,11 +399,11 @@ pub const ElfFile = struct {
345399 self.shdr_table_offset = self.findFreeSpace(self.sections.items.len * shsize, shalign);
346400 self.shdr_table_dirty = true;
347401 }
348 const phsize: u64 = switch (ptr_width) {
402 const phsize: u64 = switch (self.ptr_width) {
349403 .p32 => @sizeOf(elf.Elf32_Phdr),
350404 .p64 => @sizeOf(elf.Elf64_Phdr),
351405 };
352 const phalign: u16 = switch (ptr_width) {
406 const phalign: u16 = switch (self.ptr_width) {
353407 .p32 => @alignOf(elf.Elf32_Phdr),
354408 .p64 => @alignOf(elf.Elf64_Phdr),
355409 };
......@@ -399,7 +453,7 @@ pub const ElfFile = struct {
399453 try self.file.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
400454 },
401455 }
402 self.phdr_table_offset = false;
456 self.phdr_table_dirty = false;
403457 }
404458
405459 {
......@@ -432,11 +486,10 @@ pub const ElfFile = struct {
432486 self.shdr_table_offset = self.findFreeSpace(needed_size, phalign);
433487 }
434488
435 const allocator = self.sections.allocator;
436489 switch (self.ptr_width) {
437490 .p32 => {
438 const buf = try allocator.alloc(elf.Elf32_Shdr, self.sections.items.len);
439 defer allocator.free(buf);
491 const buf = try self.allocator.alloc(elf.Elf32_Shdr, self.sections.items.len);
492 defer self.allocator.free(buf);
440493
441494 for (buf) |*shdr, i| {
442495 shdr.* = sectHeaderTo32(self.sections.items[i]);
......@@ -447,8 +500,8 @@ pub const ElfFile = struct {
447500 try self.file.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
448501 },
449502 .p64 => {
450 const buf = try allocator.alloc(elf.Elf64_Shdr, self.sections.items.len);
451 defer allocator.free(buf);
503 const buf = try self.allocator.alloc(elf.Elf64_Shdr, self.sections.items.len);
504 defer self.allocator.free(buf);
452505
453506 for (buf) |*shdr, i| {
454507 shdr.* = self.sections.items[i];
......@@ -460,6 +513,7 @@ pub const ElfFile = struct {
460513 try self.file.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
461514 },
462515 }
516 self.shdr_table_dirty = false;
463517 }
464518 if (self.entry_addr == null and self.options.output_mode == .Exe) {
465519 self.error_flags.no_entry_point_found = true;
......@@ -470,11 +524,11 @@ pub const ElfFile = struct {
470524 // TODO find end pos and truncate
471525
472526 // The point of flush() is to commit changes, so nothing should be dirty after this.
473 assert(!self.phdr_load_re_dirty);
474527 assert(!self.phdr_table_dirty);
475528 assert(!self.shdr_table_dirty);
476529 assert(!self.shstrtab_dirty);
477 assert(!self.symtab_dirty);
530 assert(!self.symbol_count_dirty);
531 assert(!self.offset_table_count_dirty);
478532 }
479533
480534 fn writeElfHeader(self: *ElfFile) !void {
......@@ -608,6 +662,7 @@ pub const ElfFile = struct {
608662 const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
609663 const shdr = &self.sections.items[self.text_section_index.?];
610664
665 // TODO Also detect virtual address collisions.
611666 const text_capacity = self.allocatedSize(shdr.sh_offset);
612667 // TODO instead of looping here, maintain a free list and a pointer to the end.
613668 const end_vaddr = blk: {
......@@ -664,7 +719,7 @@ pub const ElfFile = struct {
664719 defer code.deinit();
665720
666721 const typed_value = decl.typed_value.most_recent.typed_value;
667 const err_msg = try codegen.generateSymbol(typed_value, module, &code, module.allocator);
722 const err_msg = try codegen.generateSymbol(typed_value, module, &code);
668723 if (err_msg != null) |em| {
669724 decl.analysis = .codegen_failure;
670725 _ = try module.failed_decls.put(decl, em);
......@@ -678,26 +733,31 @@ pub const ElfFile = struct {
678733 else => elf.STT_OBJECT,
679734 };
680735
681 if (decl.link.local_sym_index) |local_sym_index| {
682 const local_sym = &self.symbols.items[local_sym_index];
736 if (decl.link.local_sym_index != 0) {
737 const local_sym = &self.symbols.items[decl.link.local_sym_index];
683738 const existing_block = self.findAllocatedTextBlock(local_sym);
684739 const file_offset = if (code_size > existing_block.size_capacity) fo: {
685 const new_block = self.allocateTextBlock(code_size);
740 const new_block = try self.allocateTextBlock(code_size);
686741 local_sym.st_value = new_block.vaddr;
687742 local_sym.st_size = code_size;
743
744 try self.writeOffsetTableEntry(decl.link.offset_table_index);
745
688746 break :fo new_block.file_offset;
689747 } else existing_block.file_offset;
690748 local_sym.st_name = try self.updateString(local_sym.st_name, mem.spanZ(u8, decl.name));
691749 local_sym.st_info = (elf.STB_LOCAL << 4) | stt_bits;
692750 // TODO this write could be avoided if no fields of the symbol were changed.
693 try self.writeSymbol(local_sym_index);
751 try self.writeSymbol(decl.link.local_sym_index);
694752 break :blk file_offset;
695753 } else {
696754 try self.symbols.ensureCapacity(self.symbols.items.len + 1);
755 try self.offset_table.ensureCapacity(self.offset_table.items.len + 1);
697756 const decl_name = mem.spanZ(u8, decl.name);
698757 const name_str_index = try self.makeString(decl_name);
699 const new_block = self.allocateTextBlock(code_size);
758 const new_block = try self.allocateTextBlock(code_size);
700759 const local_sym_index = self.symbols.items.len;
760 const offset_table_index = self.offset_table.items.len;
701761
702762 self.symbols.appendAssumeCapacity(self.allocator, .{
703763 .st_name = name_str_index,
......@@ -708,10 +768,17 @@ pub const ElfFile = struct {
708768 .st_size = code_size,
709769 });
710770 errdefer self.symbols.shrink(self.symbols.items.len - 1);
771 self.offset_table.appendAssumeCapacity(self.allocator, new_block.vaddr);
772 errdefer self.offset_table.shrink(self.offset_table.items.len - 1);
711773 try self.writeSymbol(local_sym_index);
774 try self.writeOffsetTableEntry(offset_table_index);
712775
713776 self.symbol_count_dirty = true;
714 decl.link.local_sym_index = local_sym_index;
777 self.offset_table_count_dirty = true;
778 decl.link = .{
779 .local_sym_index = local_sym_index,
780 .offset_table_index = offset_table_index,
781 };
715782
716783 break :blk new_block.file_offset;
717784 }
......@@ -839,6 +906,45 @@ pub const ElfFile = struct {
839906 }
840907 }
841908
909 fn writeOffsetTableEntry(self: *ElfFile, index: usize) !void {
910 const shdr = &self.sections.items[self.got_section_index.?];
911 const phdr = &self.program_headers.items[self.phdr_got_index.?];
912 if (self.offset_table_count_dirty) {
913 // TODO Also detect virtual address collisions.
914 const allocated_size = self.allocatedSize(shdr.sh_offset);
915 const needed_size = self.symbols.items.len * shdr.sh_entsize;
916 if (needed_size > allocated_size) {
917 // Must move the entire got section.
918 const new_offset = self.findFreeSpace(needed_size, shdr.sh_entsize);
919 const amt = try self.file.copyRangeAll(shdr.sh_offset, self.file, new_offset, shdr.sh_size);
920 if (amt != text_size) return error.InputOutput;
921 shdr.sh_offset = new_offset;
922 }
923 shdr.sh_size = needed_size;
924 phdr.p_memsz = needed_size;
925 phdr.p_filesz = needed_size;
926
927 self.shdr_table_dirty = true; // TODO look into making only the one section dirty
928 self.phdr_table_dirty = true; // TODO look into making only the one program header dirty
929
930 self.offset_table_count_dirty = false;
931 }
932 const endian = self.options.target.cpu.arch.endian();
933 const off = shdr.sh_offset + shdr.sh_entsize * index;
934 switch (self.ptr_width) {
935 .p32 => {
936 var buf: [4]u8 = undefined;
937 mem.writeInt(u32, &buf, @intCast(u32, self.offset_table.items[index]), endian);
938 try self.file.pwriteAll(&buf, off);
939 },
940 .p64 => {
941 var buf: [8]u8 = undefined;
942 mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
943 try self.file.pwriteAll(&buf, off);
944 },
945 }
946 }
947
842948 fn writeSymbol(self: *ElfFile, index: usize) !void {
843949 const syms_sect = &self.sections.items[self.symtab_section_index.?];
844950 // Make sure we are not pointlessly writing symbol data that will have to get relocated
......@@ -849,6 +955,9 @@ pub const ElfFile = struct {
849955 if (needed_size > allocated_size) {
850956 return self.writeAllSymbols();
851957 }
958 syms_sect.sh_info = @intCast(u32, self.symbols.items.len);
959 self.shdr_table_dirty = true; // TODO look into only writing one section
960 self.symbol_count_dirty = false;
852961 }
853962 const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
854963 switch (self.ptr_width) {
......@@ -896,12 +1005,13 @@ pub const ElfFile = struct {
8961005 //std.debug.warn("symtab start=0x{x} end=0x{x}\n", .{ syms_sect.sh_offset, syms_sect.sh_offset + needed_size });
8971006 syms_sect.sh_size = needed_size;
8981007 syms_sect.sh_info = @intCast(u32, self.symbols.items.len);
899 const allocator = self.symbols.allocator;
1008 self.symbol_count_dirty = false;
1009 self.shdr_table_dirty = true; // TODO look into only writing one section
9001010 const foreign_endian = self.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
9011011 switch (self.ptr_width) {
9021012 .p32 => {
903 const buf = try allocator.alloc(elf.Elf32_Sym, self.symbols.items.len);
904 defer allocator.free(buf);
1013 const buf = try self.allocator.alloc(elf.Elf32_Sym, self.symbols.items.len);
1014 defer self.allocator.free(buf);
9051015
9061016 for (buf) |*sym, i| {
9071017 sym.* = .{
......@@ -919,8 +1029,8 @@ pub const ElfFile = struct {
9191029 try self.file.pwriteAll(mem.sliceAsBytes(buf), syms_sect.sh_offset);
9201030 },
9211031 .p64 => {
922 const buf = try allocator.alloc(elf.Elf64_Sym, self.symbols.items.len);
923 defer allocator.free(buf);
1032 const buf = try self.allocator.alloc(elf.Elf64_Sym, self.symbols.items.len);
1033 defer self.allocator.free(buf);
9241034
9251035 for (buf) |*sym, i| {
9261036 sym.* = .{
......@@ -961,12 +1071,11 @@ pub fn createElfFile(allocator: *Allocator, file: fs.File, options: Options) !El
9611071 .allocator = allocator,
9621072 .file = file,
9631073 .options = options,
964 .ptr_width = switch (self.options.target.cpu.arch.ptrBitWidth()) {
1074 .ptr_width = switch (options.target.cpu.arch.ptrBitWidth()) {
9651075 32 => .p32,
9661076 64 => .p64,
9671077 else => return error.UnsupportedELFArchitecture,
9681078 },
969 .symtab_dirty = true,
9701079 .shdr_table_dirty = true,
9711080 };
9721081 errdefer self.deinit();
......@@ -1018,7 +1127,7 @@ fn openBinFileInner(allocator: *Allocator, file: fs.File, options: Options) !Elf
10181127 .allocator = allocator,
10191128 .file = file,
10201129 .options = options,
1021 .ptr_width = switch (self.options.target.cpu.arch.ptrBitWidth()) {
1130 .ptr_width = switch (options.target.cpu.arch.ptrBitWidth()) {
10221131 32 => .p32,
10231132 64 => .p64,
10241133 else => return error.UnsupportedELFArchitecture,