motiejus/zig
1
Fork 0
Code Releases Activity

macho: init metadata for incremental linking

Browse Source
This commit is contained in:
Jakub Konka
2024-01-18 12:56:27 +01:00
parent 8c578ba02c
commit a6ed54ea22
2 changed files with 114 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
src/link/MachO.zig
View File

@@ -85,15 +85,17 @@ unwind_info: UnwindInfo = .{},
/// Tracked loadable segments during incremental linking.
zig_text_seg_index: ?u8 = null,
zig_data_const_seg_index: ?u8 = null,
zig_got_seg_index: ?u8 = null,
zig_const_seg_index: ?u8 = null,
zig_data_seg_index: ?u8 = null,
zig_bss_seg_index: ?u8 = null,
/// Tracked section headers with incremental updates to Zig object.
zig_text_section_index: ?u8 = null,
zig_data_const_section_index: ?u8 = null,
zig_got_section_index: ?u8 = null,
zig_const_section_index: ?u8 = null,
zig_data_section_index: ?u8 = null,
zig_bss_section_index: ?u8 = null,
zig_got_section_index: ?u8 = null,
has_tlv: bool = false,
binds_to_weak: bool = false,
@@ -252,6 +254,8 @@ pub fn createEmpty(
.program_code_size_hint = options.program_code_size_hint,
});
std.debug.print("{}", .{self.dumpState()});
// TODO init dwarf
// if (comp.config.debug_format != .strip) {
@@ -3082,33 +3086,45 @@ pub fn padToIdeal(actual_size: anytype) @TypeOf(actual_size) {
}
fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
// TODO: header and load commands have to be part of the __TEXT segment
const header_size = self.segments.items[self.header_segment_cmd_index.?].filesize;
// Conservatively commit one page size as reserved space for the headers as we
// expect it to grow and everything else be moved in flush anyhow.
const header_size = self.getPageSize();
if (start < header_size)
return header_size;
const end = start + padToIdeal(size);
for (self.sections.items(.header)) |header| {
const tight_size = header.size;
const increased_size = padToIdeal(tight_size);
if (header.isZerofill()) continue;
const increased_size = padToIdeal(header.size);
const test_end = header.offset + increased_size;
if (end > header.offset and start < test_end) {
return test_end;
}
}
for (self.segments.items) |seg| {
const increased_size = padToIdeal(seg.filesize);
const test_end = seg.fileoff +| increased_size;
if (end > seg.fileoff and start < test_end) {
return test_end;
}
}
return null;
}
fn allocatedSize(self: *MachO, start: u64) u64 {
if (start == 0)
return 0;
if (start == 0) return 0;
var min_pos: u64 = std.math.maxInt(u64);
for (self.sections.items(.header)) |header| {
if (header.offset <= start) continue;
if (header.offset < min_pos) min_pos = header.offset;
}
for (self.segments.items) |seg| {
if (seg.fileoff <= start) continue;
if (seg.fileoff < min_pos) min_pos = seg.fileoff;
}
return min_pos - start;
}
@@ -3126,36 +3142,113 @@ const InitMetadataOptions = struct {
};
// TODO: move to ZigObject
// TODO: bring back pre-alloc of segments/sections
fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
_ = options;
if (!self.base.isRelocatable()) {
// TODO: If we are not emitting a relocatable object file, init segments.
const base_vmaddr = blk: {
const pagezero_size = self.pagezero_size orelse default_pagezero_size;
break :blk mem.alignBackward(u64, pagezero_size, self.getPageSize());
};
{
const filesize = options.program_code_size_hint;
const off = self.findFreeSpace(filesize, self.getPageSize());
self.zig_text_seg_index = try self.addSegment("__TEXT_ZIG", .{
.fileoff = off,
.filesize = filesize,
.vmaddr = base_vmaddr + 0x8000000,
.vmsize = filesize,
.prot = macho.PROT.READ | macho.PROT.EXEC,
});
}
{
const filesize = options.symbol_count_hint * @sizeOf(u64);
const off = self.findFreeSpace(filesize, self.getPageSize());
self.zig_got_seg_index = try self.addSegment("__GOT_ZIG", .{
.fileoff = off,
.filesize = filesize,
.vmaddr = base_vmaddr + 0x4000000,
.vmsize = filesize,
.prot = macho.PROT.READ | macho.PROT.WRITE,
});
}
{
const filesize: u64 = 1024;
const off = self.findFreeSpace(filesize, self.getPageSize());
self.zig_const_seg_index = try self.addSegment("__CONST_ZIG", .{
.fileoff = off,
.filesize = filesize,
.vmaddr = base_vmaddr + 0xc000000,
.vmsize = filesize,
.prot = macho.PROT.READ | macho.PROT.WRITE,
});
}
{
const filesize: u64 = 1024;
const off = self.findFreeSpace(filesize, self.getPageSize());
self.zig_data_seg_index = try self.addSegment("__DATA_ZIG", .{
.fileoff = off,
.filesize = filesize,
.vmaddr = base_vmaddr + 0x10000000,
.vmsize = filesize,
.prot = macho.PROT.READ | macho.PROT.WRITE,
});
}
{
const memsize: u64 = 1024;
self.zig_bss_seg_index = try self.addSegment("__BSS_ZIG", .{
.vmaddr = base_vmaddr + 0x14000000,
.vmsize = memsize,
.prot = macho.PROT.READ | macho.PROT.WRITE,
});
}
} else {
@panic("TODO initMetadata when relocatable");
}
const appendSect = struct {
fn appendSect(macho_file: *MachO, sect_id: u8, seg_id: u8) void {
const sect = &macho_file.sections.items(.header)[sect_id];
const seg = &macho_file.segments.items[seg_id];
seg.cmdsize += @sizeOf(macho.section_64);
seg.nsects += 1;
sect.addr = seg.vmaddr;
sect.offset = @intCast(seg.fileoff);
sect.size = seg.vmsize;
macho_file.sections.items(.segment_id)[sect_id] = seg_id;
}
}.appendSect;
if (self.zig_text_section_index == null) {
self.zig_text_section_index = try self.addSection("__TEXT", "__text", .{
self.zig_text_section_index = try self.addSection("__TEXT_ZIG", "__text_zig", .{
.flags = macho.S_REGULAR | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS,
});
appendSect(self, self.zig_text_section_index.?, self.zig_text_seg_index.?);
}
if (self.zig_got_section_index == null and !self.base.isRelocatable()) {
self.zig_got_section_index = try self.addSection("__DATA_CONST", "__got_zig", .{});
self.zig_got_section_index = try self.addSection("__GOT_ZIG", "__got_zig", .{});
appendSect(self, self.zig_got_section_index.?, self.zig_got_seg_index.?);
}
if (self.zig_data_const_section_index == null) {
self.zig_data_const_section_index = try self.addSection("__DATA_CONST", "__const", .{});
if (self.zig_const_section_index == null) {
self.zig_const_section_index = try self.addSection("__CONST_ZIG", "__const_zig", .{});
appendSect(self, self.zig_const_section_index.?, self.zig_const_seg_index.?);
}
if (self.zig_data_section_index == null) {
self.zig_data_section_index = try self.addSection("__DATA", "__data", .{});
self.zig_data_section_index = try self.addSection("__DATA_ZIG", "__data_zig", .{});
appendSect(self, self.zig_data_section_index.?, self.zig_data_seg_index.?);
}
if (self.zig_bss_section_index == null) {
self.zig_bss_section_index = try self.addSection("__DATA", "_bss", .{
self.zig_bss_section_index = try self.addSection("__BSS_ZIG", "__bss_zig", .{
.flags = macho.S_ZEROFILL,
});
appendSect(self, self.zig_bss_section_index.?, self.zig_bss_seg_index.?);
}
}

4
src/link/MachO/ZigObject.zig
View File

@@ -478,7 +478,7 @@ fn getDeclOutputSection(
);
}
if (variable.is_const) break :blk macho_file.zig_data_const_section_index.?;
if (variable.is_const) break :blk macho_file.zig_const_section_index.?;
if (Value.fromInterned(variable.init).isUndefDeep(mod)) {
// TODO: get the optimize_mode from the Module that owns the decl instead
// of using the root module here.
@@ -496,7 +496,7 @@ fn getDeclOutputSection(
if (is_all_zeroes) break :blk macho_file.zig_bss_section_index.?;
break :blk macho_file.zig_data_section_index.?;
}
break :blk macho_file.zig_data_const_section_index.?;
break :blk macho_file.zig_const_section_index.?;
},
};
return sect_id;