| ... | ... | @@ -332,7 +332,7 @@ fn mapAndUpdateSections( |
| 332 | 332 | const target_seg = &self.load_commands.items[target_seg_id].Segment; |
| 333 | 333 | const target_sect = &target_seg.sections.items[target_sect_id]; |
| 334 | 334 | |
| 335 | | const alignment = try math.powi(u32, 2, source_sect.@"align"); |
| 335 | const alignment = try math.powi(u32, 2, target_sect.@"align"); |
| 336 | 336 | const offset = mem.alignForwardGeneric(u64, target_sect.size, alignment); |
| 337 | 337 | const size = mem.alignForwardGeneric(u64, source_sect.size, alignment); |
| 338 | 338 | const key = MappingKey{ |
| ... | ... | @@ -345,7 +345,7 @@ fn mapAndUpdateSections( |
| 345 | 345 | .target_sect_id = target_sect_id, |
| 346 | 346 | .offset = @intCast(u32, offset), |
| 347 | 347 | }); |
| 348 | | log.debug("{s}: {s},{s} mapped to {s},{s} from 0x{x} to 0x{x}", .{ |
| 348 | log.warn("{s}: {s},{s} mapped to {s},{s} from 0x{x} to 0x{x}", .{ |
| 349 | 349 | object.name, |
| 350 | 350 | parseName(&source_sect.segname), |
| 351 | 351 | parseName(&source_sect.sectname), |
| ... | ... | @@ -355,7 +355,6 @@ fn mapAndUpdateSections( |
| 355 | 355 | offset + size, |
| 356 | 356 | }); |
| 357 | 357 | |
| 358 | | target_sect.@"align" = math.max(target_sect.@"align", source_sect.@"align"); |
| 359 | 358 | target_sect.size = offset + size; |
| 360 | 359 | } |
| 361 | 360 | |
| ... | ... | @@ -514,120 +513,117 @@ fn updateMetadata(self: *Zld, object_id: u16) !void { |
| 514 | 513 | }); |
| 515 | 514 | }, |
| 516 | 515 | else => { |
| 517 | | log.debug("unhandled section type 0x{x} for '{s}/{s}'", .{ flags, segname, sectname }); |
| 516 | log.warn("unhandled section type 0x{x} for '{s}/{s}'", .{ flags, segname, sectname }); |
| 518 | 517 | }, |
| 519 | 518 | } |
| 520 | 519 | } |
| 521 | 520 | |
| 522 | | // Update section mappings |
| 523 | | // __TEXT,__text has to be always defined! |
| 524 | | try self.mapAndUpdateSections( |
| 525 | | object_id, |
| 526 | | object.text_section_index.?, |
| 527 | | self.text_segment_cmd_index.?, |
| 528 | | self.text_section_index.?, |
| 529 | | ); |
| 521 | // Find ideal section alignment. |
| 522 | for (object_seg.sections.items) |source_sect, id| { |
| 523 | if (self.getMatchingSection(source_sect)) |res| { |
| 524 | const target_seg = &self.load_commands.items[res.seg].Segment; |
| 525 | const target_sect = &target_seg.sections.items[res.sect]; |
| 526 | target_sect.@"align" = math.max(target_sect.@"align", source_sect.@"align"); |
| 527 | } |
| 528 | } |
| 530 | 529 | |
| 530 | // Update section mappings |
| 531 | 531 | for (object_seg.sections.items) |source_sect, id| { |
| 532 | 532 | const source_sect_id = @intCast(u16, id); |
| 533 | | if (id == object.text_section_index.?) continue; |
| 533 | if (self.getMatchingSection(source_sect)) |res| { |
| 534 | try self.mapAndUpdateSections(object_id, source_sect_id, res.seg, res.sect); |
| 535 | continue; |
| 536 | } |
| 534 | 537 | |
| 535 | 538 | const segname = parseName(&source_sect.segname); |
| 536 | 539 | const sectname = parseName(&source_sect.sectname); |
| 537 | | const flags = source_sect.flags; |
| 540 | log.warn("section '{s}/{s}' will be unmapped", .{ segname, sectname }); |
| 541 | try self.unhandled_sections.putNoClobber(self.allocator, .{ |
| 542 | .object_id = object_id, |
| 543 | .source_sect_id = source_sect_id, |
| 544 | }, 0); |
| 545 | } |
| 546 | } |
| 538 | 547 | |
| 539 | | switch (flags) { |
| 548 | const MatchingSection = struct { |
| 549 | seg: u16, |
| 550 | sect: u16, |
| 551 | }; |
| 552 | |
| 553 | fn getMatchingSection(self: *Zld, section: macho.section_64) ?MatchingSection { |
| 554 | const segname = parseName(§ion.segname); |
| 555 | const sectname = parseName(§ion.sectname); |
| 556 | const res: ?MatchingSection = blk: { |
| 557 | switch (section.flags) { |
| 540 | 558 | macho.S_4BYTE_LITERALS, macho.S_8BYTE_LITERALS, macho.S_16BYTE_LITERALS => { |
| 541 | | try self.mapAndUpdateSections( |
| 542 | | object_id, |
| 543 | | source_sect_id, |
| 544 | | self.text_segment_cmd_index.?, |
| 545 | | self.text_const_section_index.?, |
| 546 | | ); |
| 559 | break :blk .{ |
| 560 | .seg = self.text_segment_cmd_index.?, |
| 561 | .sect = self.text_const_section_index.?, |
| 562 | }; |
| 547 | 563 | }, |
| 548 | 564 | macho.S_CSTRING_LITERALS => { |
| 549 | | try self.mapAndUpdateSections( |
| 550 | | object_id, |
| 551 | | source_sect_id, |
| 552 | | self.text_segment_cmd_index.?, |
| 553 | | self.cstring_section_index.?, |
| 554 | | ); |
| 565 | break :blk .{ |
| 566 | .seg = self.text_segment_cmd_index.?, |
| 567 | .sect = self.cstring_section_index.?, |
| 568 | }; |
| 555 | 569 | }, |
| 556 | 570 | macho.S_ZEROFILL => { |
| 557 | | try self.mapAndUpdateSections( |
| 558 | | object_id, |
| 559 | | source_sect_id, |
| 560 | | self.data_segment_cmd_index.?, |
| 561 | | self.bss_section_index.?, |
| 562 | | ); |
| 571 | break :blk .{ |
| 572 | .seg = self.data_segment_cmd_index.?, |
| 573 | .sect = self.bss_section_index.?, |
| 574 | }; |
| 563 | 575 | }, |
| 564 | 576 | macho.S_THREAD_LOCAL_VARIABLES => { |
| 565 | | try self.mapAndUpdateSections( |
| 566 | | object_id, |
| 567 | | source_sect_id, |
| 568 | | self.data_segment_cmd_index.?, |
| 569 | | self.tlv_section_index.?, |
| 570 | | ); |
| 577 | break :blk .{ |
| 578 | .seg = self.data_segment_cmd_index.?, |
| 579 | .sect = self.tlv_section_index.?, |
| 580 | }; |
| 571 | 581 | }, |
| 572 | 582 | macho.S_THREAD_LOCAL_REGULAR => { |
| 573 | | try self.mapAndUpdateSections( |
| 574 | | object_id, |
| 575 | | source_sect_id, |
| 576 | | self.data_segment_cmd_index.?, |
| 577 | | self.tlv_data_section_index.?, |
| 578 | | ); |
| 583 | break :blk .{ |
| 584 | .seg = self.data_segment_cmd_index.?, |
| 585 | .sect = self.tlv_data_section_index.?, |
| 586 | }; |
| 579 | 587 | }, |
| 580 | 588 | macho.S_THREAD_LOCAL_ZEROFILL => { |
| 581 | | try self.mapAndUpdateSections( |
| 582 | | object_id, |
| 583 | | source_sect_id, |
| 584 | | self.data_segment_cmd_index.?, |
| 585 | | self.tlv_bss_section_index.?, |
| 586 | | ); |
| 589 | break :blk .{ |
| 590 | .seg = self.data_segment_cmd_index.?, |
| 591 | .sect = self.tlv_bss_section_index.?, |
| 592 | }; |
| 593 | }, |
| 594 | macho.S_REGULAR | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS => { |
| 595 | break :blk .{ |
| 596 | .seg = self.text_segment_cmd_index.?, |
| 597 | .sect = self.text_section_index.?, |
| 598 | }; |
| 587 | 599 | }, |
| 588 | 600 | macho.S_REGULAR => { |
| 589 | 601 | if (mem.eql(u8, segname, "__TEXT")) { |
| 590 | | try self.mapAndUpdateSections( |
| 591 | | object_id, |
| 592 | | source_sect_id, |
| 593 | | self.text_segment_cmd_index.?, |
| 594 | | self.text_const_section_index.?, |
| 595 | | ); |
| 596 | | continue; |
| 602 | break :blk .{ |
| 603 | .seg = self.text_segment_cmd_index.?, |
| 604 | .sect = self.text_const_section_index.?, |
| 605 | }; |
| 597 | 606 | } else if (mem.eql(u8, segname, "__DATA")) { |
| 598 | 607 | if (mem.eql(u8, sectname, "__data")) { |
| 599 | | try self.mapAndUpdateSections( |
| 600 | | object_id, |
| 601 | | source_sect_id, |
| 602 | | self.data_segment_cmd_index.?, |
| 603 | | self.data_section_index.?, |
| 604 | | ); |
| 605 | | continue; |
| 608 | break :blk .{ |
| 609 | .seg = self.data_segment_cmd_index.?, |
| 610 | .sect = self.data_section_index.?, |
| 611 | }; |
| 606 | 612 | } else if (mem.eql(u8, sectname, "__const")) { |
| 607 | | try self.mapAndUpdateSections( |
| 608 | | object_id, |
| 609 | | source_sect_id, |
| 610 | | self.data_segment_cmd_index.?, |
| 611 | | self.data_const_section_index.?, |
| 612 | | ); |
| 613 | | continue; |
| 613 | break :blk .{ |
| 614 | .seg = self.data_segment_cmd_index.?, |
| 615 | .sect = self.data_const_section_index.?, |
| 616 | }; |
| 614 | 617 | } |
| 615 | 618 | } |
| 616 | | log.debug("section '{s}/{s}' will be unmapped", .{ segname, sectname }); |
| 617 | | try self.unhandled_sections.putNoClobber(self.allocator, .{ |
| 618 | | .object_id = object_id, |
| 619 | | .source_sect_id = source_sect_id, |
| 620 | | }, 0); |
| 619 | break :blk null; |
| 621 | 620 | }, |
| 622 | 621 | else => { |
| 623 | | log.debug("section '{s}/{s}' will be unmapped", .{ segname, sectname }); |
| 624 | | try self.unhandled_sections.putNoClobber(self.allocator, .{ |
| 625 | | .object_id = object_id, |
| 626 | | .source_sect_id = source_sect_id, |
| 627 | | }, 0); |
| 622 | break :blk null; |
| 628 | 623 | }, |
| 629 | 624 | } |
| 630 | | } |
| 625 | }; |
| 626 | return res; |
| 631 | 627 | } |
| 632 | 628 | |
| 633 | 629 | fn sortSections(self: *Zld) !void { |
| ... | ... | @@ -784,7 +780,7 @@ fn resolveImports(self: *Zld) !void { |
| 784 | 780 | mem.eql(u8, sym_name, "___stack_chk_guard") or |
| 785 | 781 | mem.eql(u8, sym_name, "_environ")) |
| 786 | 782 | { |
| 787 | | log.debug("writing nonlazy symbol '{s}'", .{sym_name}); |
| 783 | log.warn("writing nonlazy symbol '{s}'", .{sym_name}); |
| 788 | 784 | const index = @intCast(u32, self.nonlazy_imports.items().len); |
| 789 | 785 | try self.nonlazy_imports.putNoClobber(self.allocator, key, .{ |
| 790 | 786 | .symbol = new_sym, |
| ... | ... | @@ -792,7 +788,7 @@ fn resolveImports(self: *Zld) !void { |
| 792 | 788 | .index = index, |
| 793 | 789 | }); |
| 794 | 790 | } else if (mem.eql(u8, sym_name, "__tlv_bootstrap")) { |
| 795 | | log.debug("writing threadlocal symbol '{s}'", .{sym_name}); |
| 791 | log.warn("writing threadlocal symbol '{s}'", .{sym_name}); |
| 796 | 792 | const index = @intCast(u32, self.threadlocal_imports.items().len); |
| 797 | 793 | try self.threadlocal_imports.putNoClobber(self.allocator, key, .{ |
| 798 | 794 | .symbol = new_sym, |
| ... | ... | @@ -800,7 +796,7 @@ fn resolveImports(self: *Zld) !void { |
| 800 | 796 | .index = index, |
| 801 | 797 | }); |
| 802 | 798 | } else { |
| 803 | | log.debug("writing lazy symbol '{s}'", .{sym_name}); |
| 799 | log.warn("writing lazy symbol '{s}'", .{sym_name}); |
| 804 | 800 | const index = @intCast(u32, self.lazy_imports.items().len); |
| 805 | 801 | try self.lazy_imports.putNoClobber(self.allocator, key, .{ |
| 806 | 802 | .symbol = new_sym, |
| ... | ... | @@ -812,7 +808,7 @@ fn resolveImports(self: *Zld) !void { |
| 812 | 808 | |
| 813 | 809 | const n_strx = try self.makeString("dyld_stub_binder"); |
| 814 | 810 | const name = try self.allocator.dupe(u8, "dyld_stub_binder"); |
| 815 | | log.debug("writing nonlazy symbol 'dyld_stub_binder'", .{}); |
| 811 | log.warn("writing nonlazy symbol 'dyld_stub_binder'", .{}); |
| 816 | 812 | const index = @intCast(u32, self.nonlazy_imports.items().len); |
| 817 | 813 | try self.nonlazy_imports.putNoClobber(self.allocator, name, .{ |
| 818 | 814 | .symbol = .{ |
| ... | ... | @@ -1016,7 +1012,7 @@ fn writeStubHelperCommon(self: *Zld) !void { |
| 1016 | 1012 | const new_this_addr = this_addr + @sizeOf(u32); |
| 1017 | 1013 | const displacement = math.divExact(u64, target_addr - new_this_addr, 4) catch |_| break :binder_blk; |
| 1018 | 1014 | const literal = math.cast(u18, displacement) catch |_| break :binder_blk; |
| 1019 | | log.debug("2: disp=0x{x}, literal=0x{x}", .{ displacement, literal }); |
| 1015 | log.warn("2: disp=0x{x}, literal=0x{x}", .{ displacement, literal }); |
| 1020 | 1016 | // Pad with nop to please division. |
| 1021 | 1017 | // nop |
| 1022 | 1018 | mem.writeIntLittle(u32, code[12..16], Arm64.nop().toU32()); |
| ... | ... | @@ -1069,7 +1065,7 @@ fn writeLazySymbolPointer(self: *Zld, index: u32) !void { |
| 1069 | 1065 | var buf: [@sizeOf(u64)]u8 = undefined; |
| 1070 | 1066 | mem.writeIntLittle(u64, &buf, end); |
| 1071 | 1067 | const off = la_symbol_ptr.offset + index * @sizeOf(u64); |
| 1072 | | log.debug("writing lazy symbol pointer entry 0x{x} at 0x{x}", .{ end, off }); |
| 1068 | log.warn("writing lazy symbol pointer entry 0x{x} at 0x{x}", .{ end, off }); |
| 1073 | 1069 | try self.file.?.pwriteAll(&buf, off); |
| 1074 | 1070 | } |
| 1075 | 1071 | |
| ... | ... | @@ -1082,7 +1078,7 @@ fn writeStub(self: *Zld, index: u32) !void { |
| 1082 | 1078 | const stub_off = stubs.offset + index * stubs.reserved2; |
| 1083 | 1079 | const stub_addr = stubs.addr + index * stubs.reserved2; |
| 1084 | 1080 | const la_ptr_addr = la_symbol_ptr.addr + index * @sizeOf(u64); |
| 1085 | | log.debug("writing stub at 0x{x}", .{stub_off}); |
| 1081 | log.warn("writing stub at 0x{x}", .{stub_off}); |
| 1086 | 1082 | var code = try self.allocator.alloc(u8, stubs.reserved2); |
| 1087 | 1083 | defer self.allocator.free(code); |
| 1088 | 1084 | switch (self.arch.?) { |
| ... | ... | @@ -1229,7 +1225,7 @@ fn resolveSymbols(self: *Zld) !void { |
| 1229 | 1225 | const target_addr = target_sect.addr + target_mapping.offset; |
| 1230 | 1226 | const n_value = sym.n_value - source_sect.addr + target_addr; |
| 1231 | 1227 | |
| 1232 | | log.debug("resolving '{s}':{} as {s} symbol at 0x{x}", .{ sym_name, sym, tt, n_value }); |
| 1228 | log.warn("resolving '{s}':{} as {s} symbol at 0x{x}", .{ sym_name, sym, tt, n_value }); |
| 1233 | 1229 | |
| 1234 | 1230 | // TODO this assumes only two symbol-filled segments. Also, there might be a more |
| 1235 | 1231 | // generic way of doing this. |
| ... | ... | @@ -1259,8 +1255,8 @@ fn resolveSymbols(self: *Zld) !void { |
| 1259 | 1255 | |
| 1260 | 1256 | fn doRelocs(self: *Zld) !void { |
| 1261 | 1257 | for (self.objects.items) |object, object_id| { |
| 1262 | | log.debug("\n\n", .{}); |
| 1263 | | log.debug("relocating object {s}", .{object.name}); |
| 1258 | log.warn("\n\n", .{}); |
| 1259 | log.warn("relocating object {s}", .{object.name}); |
| 1264 | 1260 | |
| 1265 | 1261 | const seg = object.load_commands.items[object.segment_cmd_index.?].Segment; |
| 1266 | 1262 | |
| ... | ... | @@ -1283,7 +1279,7 @@ fn doRelocs(self: *Zld) !void { |
| 1283 | 1279 | .object_id = @intCast(u16, object_id), |
| 1284 | 1280 | .source_sect_id = @intCast(u16, source_sect_id), |
| 1285 | 1281 | }) orelse { |
| 1286 | | log.debug("no mapping for {s},{s}; skipping", .{ segname, sectname }); |
| 1282 | log.warn("no mapping for {s},{s}; skipping", .{ segname, sectname }); |
| 1287 | 1283 | continue; |
| 1288 | 1284 | }; |
| 1289 | 1285 | const target_seg = self.load_commands.items[target_mapping.target_seg_id].Segment; |
| ... | ... | @@ -1301,34 +1297,34 @@ fn doRelocs(self: *Zld) !void { |
| 1301 | 1297 | switch (self.arch.?) { |
| 1302 | 1298 | .aarch64 => { |
| 1303 | 1299 | const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type); |
| 1304 | | log.debug("{s}", .{rel_type}); |
| 1305 | | log.debug(" | source address 0x{x}", .{this_addr}); |
| 1306 | | log.debug(" | offset 0x{x}", .{off}); |
| 1300 | log.warn("{s}", .{rel_type}); |
| 1301 | log.warn(" | source address 0x{x}", .{this_addr}); |
| 1302 | log.warn(" | offset 0x{x}", .{off}); |
| 1307 | 1303 | |
| 1308 | 1304 | if (rel_type == .ARM64_RELOC_ADDEND) { |
| 1309 | 1305 | addend = rel.r_symbolnum; |
| 1310 | | log.debug(" | calculated addend = 0x{x}", .{addend}); |
| 1306 | log.warn(" | calculated addend = 0x{x}", .{addend}); |
| 1311 | 1307 | // TODO followed by either PAGE21 or PAGEOFF12 only. |
| 1312 | 1308 | continue; |
| 1313 | 1309 | } |
| 1314 | 1310 | }, |
| 1315 | 1311 | .x86_64 => { |
| 1316 | 1312 | const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type); |
| 1317 | | log.debug("{s}", .{rel_type}); |
| 1318 | | log.debug(" | source address 0x{x}", .{this_addr}); |
| 1319 | | log.debug(" | offset 0x{x}", .{off}); |
| 1313 | log.warn("{s}", .{rel_type}); |
| 1314 | log.warn(" | source address 0x{x}", .{this_addr}); |
| 1315 | log.warn(" | offset 0x{x}", .{off}); |
| 1320 | 1316 | }, |
| 1321 | 1317 | else => {}, |
| 1322 | 1318 | } |
| 1323 | 1319 | |
| 1324 | 1320 | const target_addr = try self.relocTargetAddr(@intCast(u16, object_id), rel); |
| 1325 | | log.debug(" | target address 0x{x}", .{target_addr}); |
| 1321 | log.warn(" | target address 0x{x}", .{target_addr}); |
| 1326 | 1322 | if (rel.r_extern == 1) { |
| 1327 | 1323 | const target_symname = object.getString(object.symtab.items[rel.r_symbolnum].n_strx); |
| 1328 | | log.debug(" | target symbol '{s}'", .{target_symname}); |
| 1324 | log.warn(" | target symbol '{s}'", .{target_symname}); |
| 1329 | 1325 | } else { |
| 1330 | 1326 | const target_sectname = seg.sections.items[rel.r_symbolnum - 1].sectname; |
| 1331 | | log.debug(" | target section '{s}'", .{parseName(&target_sectname)}); |
| 1327 | log.warn(" | target section '{s}'", .{parseName(&target_sectname)}); |
| 1332 | 1328 | } |
| 1333 | 1329 | |
| 1334 | 1330 | switch (self.arch.?) { |
| ... | ... | @@ -1361,13 +1357,12 @@ fn doRelocs(self: *Zld) !void { |
| 1361 | 1357 | => { |
| 1362 | 1358 | assert(rel.r_length == 2); |
| 1363 | 1359 | const inst = code[off..][0..4]; |
| 1364 | | const offset: i32 = blk: { |
| 1360 | const offset = @intCast(i64, mem.readIntLittle(i32, inst)); |
| 1361 | log.warn(" | calculated addend 0x{x}", .{offset}); |
| 1362 | const actual_target_addr = blk: { |
| 1365 | 1363 | if (rel.r_extern == 1) { |
| 1366 | | break :blk mem.readIntLittle(i32, inst); |
| 1364 | break :blk @intCast(i64, target_addr) + offset; |
| 1367 | 1365 | } else { |
| 1368 | | // TODO it might be required here to parse the offset from the instruction placeholder, |
| 1369 | | // compare the displacement with the original displacement in the .o file, and adjust |
| 1370 | | // the displacement in the resultant binary file. |
| 1371 | 1366 | const correction: i4 = switch (rel_type) { |
| 1372 | 1367 | .X86_64_RELOC_SIGNED => 0, |
| 1373 | 1368 | .X86_64_RELOC_SIGNED_1 => 1, |
| ... | ... | @@ -1375,11 +1370,28 @@ fn doRelocs(self: *Zld) !void { |
| 1375 | 1370 | .X86_64_RELOC_SIGNED_4 => 4, |
| 1376 | 1371 | else => unreachable, |
| 1377 | 1372 | }; |
| 1378 | | break :blk correction; |
| 1373 | log.warn(" | calculated correction 0x{x}", .{correction}); |
| 1374 | |
| 1375 | // The value encoded in the instruction is a displacement - 4 - correction. |
| 1376 | // To obtain the adjusted target address in the final binary, we need |
| 1377 | // calculate the original target address within the object file, establish |
| 1378 | // what the offset from the original target section was, and apply this |
| 1379 | // offset to the resultant target section with this relocated binary. |
| 1380 | const orig_sect_id = @intCast(u16, rel.r_symbolnum - 1); |
| 1381 | const target_map = self.mappings.get(.{ |
| 1382 | .object_id = @intCast(u16, object_id), |
| 1383 | .source_sect_id = orig_sect_id, |
| 1384 | }) orelse unreachable; |
| 1385 | const orig_seg = object.load_commands.items[object.segment_cmd_index.?].Segment; |
| 1386 | const orig_sect = orig_seg.sections.items[orig_sect_id]; |
| 1387 | const orig_offset = off + offset + 4 + correction - @intCast(i64, orig_sect.addr); |
| 1388 | log.warn(" | original offset 0x{x}", .{orig_offset}); |
| 1389 | const adjusted = @intCast(i64, target_addr) + orig_offset; |
| 1390 | log.warn(" | adjusted target address 0x{x}", .{adjusted}); |
| 1391 | break :blk adjusted - correction; |
| 1379 | 1392 | } |
| 1380 | 1393 | }; |
| 1381 | | log.debug(" | calculated addend 0x{x}", .{offset}); |
| 1382 | | const result = @intCast(i64, target_addr) - @intCast(i64, this_addr) - 4 + offset; |
| 1394 | const result = actual_target_addr - @intCast(i64, this_addr) - 4; |
| 1383 | 1395 | const displacement = @bitCast(u32, @intCast(i32, result)); |
| 1384 | 1396 | mem.writeIntLittle(u32, inst, displacement); |
| 1385 | 1397 | }, |
| ... | ... | @@ -1391,11 +1403,40 @@ fn doRelocs(self: *Zld) !void { |
| 1391 | 1403 | 3 => { |
| 1392 | 1404 | const inst = code[off..][0..8]; |
| 1393 | 1405 | const offset = mem.readIntLittle(i64, inst); |
| 1394 | | log.debug(" | calculated addend 0x{x}", .{offset}); |
| 1395 | | const result = if (sub) |s| |
| 1396 | | @intCast(i64, target_addr) - s + offset |
| 1397 | | else |
| 1398 | | @intCast(i64, target_addr) + offset; |
| 1406 | |
| 1407 | const result = outer: { |
| 1408 | if (rel.r_extern == 1) { |
| 1409 | log.warn(" | calculated addend 0x{x}", .{offset}); |
| 1410 | if (sub) |s| { |
| 1411 | break :outer @intCast(i64, target_addr) - s + offset; |
| 1412 | } else { |
| 1413 | break :outer @intCast(i64, target_addr) + offset; |
| 1414 | } |
| 1415 | } else { |
| 1416 | // The value encoded in the instruction is an absolute offset |
| 1417 | // from the start of MachO header to the target address in the |
| 1418 | // object file. To extract the address, we calculate the offset from |
| 1419 | // the beginning of the source section to the address, and apply it to |
| 1420 | // the target address value. |
| 1421 | const orig_sect_id = @intCast(u16, rel.r_symbolnum - 1); |
| 1422 | const target_map = self.mappings.get(.{ |
| 1423 | .object_id = @intCast(u16, object_id), |
| 1424 | .source_sect_id = orig_sect_id, |
| 1425 | }) orelse unreachable; |
| 1426 | const orig_seg = object.load_commands.items[object.segment_cmd_index.?].Segment; |
| 1427 | const orig_sect = orig_seg.sections.items[orig_sect_id]; |
| 1428 | const orig_offset = offset - @intCast(i64, orig_sect.addr); |
| 1429 | const actual_target_addr = inner: { |
| 1430 | if (sub) |s| { |
| 1431 | break :inner @intCast(i64, target_addr) - s + orig_offset; |
| 1432 | } else { |
| 1433 | break :inner @intCast(i64, target_addr) + orig_offset; |
| 1434 | } |
| 1435 | }; |
| 1436 | log.warn(" | adjusted target address 0x{x}", .{actual_target_addr}); |
| 1437 | break :outer actual_target_addr; |
| 1438 | } |
| 1439 | }; |
| 1399 | 1440 | mem.writeIntLittle(u64, inst, @bitCast(u64, result)); |
| 1400 | 1441 | sub = null; |
| 1401 | 1442 | |
| ... | ... | @@ -1422,7 +1463,7 @@ fn doRelocs(self: *Zld) !void { |
| 1422 | 1463 | 2 => { |
| 1423 | 1464 | const inst = code[off..][0..4]; |
| 1424 | 1465 | const offset = mem.readIntLittle(i32, inst); |
| 1425 | | log.debug(" | calculated addend 0x{x}", .{offset}); |
| 1466 | log.warn(" | calculated addend 0x{x}", .{offset}); |
| 1426 | 1467 | const result = if (sub) |s| |
| 1427 | 1468 | @intCast(i64, target_addr) - s + offset |
| 1428 | 1469 | else |
| ... | ... | @@ -1459,7 +1500,7 @@ fn doRelocs(self: *Zld) !void { |
| 1459 | 1500 | const this_page = @intCast(i32, this_addr >> 12); |
| 1460 | 1501 | const target_page = @intCast(i32, ta >> 12); |
| 1461 | 1502 | const pages = @bitCast(u21, @intCast(i21, target_page - this_page)); |
| 1462 | | log.debug(" | moving by {} pages", .{pages}); |
| 1503 | log.warn(" | moving by {} pages", .{pages}); |
| 1463 | 1504 | var parsed = mem.bytesAsValue(meta.TagPayload(Arm64, Arm64.Address), inst); |
| 1464 | 1505 | parsed.immhi = @truncate(u19, pages >> 2); |
| 1465 | 1506 | parsed.immlo = @truncate(u2, pages); |
| ... | ... | @@ -1470,14 +1511,14 @@ fn doRelocs(self: *Zld) !void { |
| 1470 | 1511 | => { |
| 1471 | 1512 | const inst = code[off..][0..4]; |
| 1472 | 1513 | if (Arm64.isArithmetic(inst)) { |
| 1473 | | log.debug(" | detected ADD opcode", .{}); |
| 1514 | log.warn(" | detected ADD opcode", .{}); |
| 1474 | 1515 | // add |
| 1475 | 1516 | var parsed = mem.bytesAsValue(meta.TagPayload(Arm64, Arm64.Add), inst); |
| 1476 | 1517 | const ta = if (addend) |a| target_addr + a else target_addr; |
| 1477 | 1518 | const narrowed = @truncate(u12, ta); |
| 1478 | 1519 | parsed.offset = narrowed; |
| 1479 | 1520 | } else { |
| 1480 | | log.debug(" | detected LDR/STR opcode", .{}); |
| 1521 | log.warn(" | detected LDR/STR opcode", .{}); |
| 1481 | 1522 | // ldr/str |
| 1482 | 1523 | var parsed = mem.bytesAsValue(meta.TagPayload(Arm64, Arm64.LoadRegister), inst); |
| 1483 | 1524 | const ta = if (addend) |a| target_addr + a else target_addr; |
| ... | ... | @@ -1518,7 +1559,7 @@ fn doRelocs(self: *Zld) !void { |
| 1518 | 1559 | }; |
| 1519 | 1560 | const ta = if (addend) |a| target_addr + a else target_addr; |
| 1520 | 1561 | const narrowed = @truncate(u12, ta); |
| 1521 | | log.debug(" | rewriting TLV access to ADD opcode", .{}); |
| 1562 | log.warn(" | rewriting TLV access to ADD opcode", .{}); |
| 1522 | 1563 | // For TLV, we always generate an add instruction. |
| 1523 | 1564 | mem.writeIntLittle(u32, inst, Arm64.add(parsed.rt, parsed.rn, narrowed, parsed.size).toU32()); |
| 1524 | 1565 | }, |
| ... | ... | @@ -1530,7 +1571,7 @@ fn doRelocs(self: *Zld) !void { |
| 1530 | 1571 | 3 => { |
| 1531 | 1572 | const inst = code[off..][0..8]; |
| 1532 | 1573 | const offset = mem.readIntLittle(i64, inst); |
| 1533 | | log.debug(" | calculated addend 0x{x}", .{offset}); |
| 1574 | log.warn(" | calculated addend 0x{x}", .{offset}); |
| 1534 | 1575 | const result = if (sub) |s| |
| 1535 | 1576 | @intCast(i64, target_addr) - s + offset |
| 1536 | 1577 | else |
| ... | ... | @@ -1561,7 +1602,7 @@ fn doRelocs(self: *Zld) !void { |
| 1561 | 1602 | 2 => { |
| 1562 | 1603 | const inst = code[off..][0..4]; |
| 1563 | 1604 | const offset = mem.readIntLittle(i32, inst); |
| 1564 | | log.debug(" | calculated addend 0x{x}", .{offset}); |
| 1605 | log.warn(" | calculated addend 0x{x}", .{offset}); |
| 1565 | 1606 | const result = if (sub) |s| |
| 1566 | 1607 | @intCast(i64, target_addr) - s + offset |
| 1567 | 1608 | else |
| ... | ... | @@ -1583,7 +1624,7 @@ fn doRelocs(self: *Zld) !void { |
| 1583 | 1624 | } |
| 1584 | 1625 | } |
| 1585 | 1626 | |
| 1586 | | log.debug("writing contents of '{s},{s}' section from '{s}' from 0x{x} to 0x{x}", .{ |
| 1627 | log.warn("writing contents of '{s},{s}' section from '{s}' from 0x{x} to 0x{x}", .{ |
| 1587 | 1628 | segname, |
| 1588 | 1629 | sectname, |
| 1589 | 1630 | object.name, |
| ... | ... | @@ -1595,7 +1636,7 @@ fn doRelocs(self: *Zld) !void { |
| 1595 | 1636 | target_sect.flags == macho.S_THREAD_LOCAL_ZEROFILL or |
| 1596 | 1637 | target_sect.flags == macho.S_THREAD_LOCAL_VARIABLES) |
| 1597 | 1638 | { |
| 1598 | | log.debug("zeroing out '{s},{s}' from 0x{x} to 0x{x}", .{ |
| 1639 | log.warn("zeroing out '{s},{s}' from 0x{x} to 0x{x}", .{ |
| 1599 | 1640 | parseName(&target_sect.segname), |
| 1600 | 1641 | parseName(&target_sect.sectname), |
| 1601 | 1642 | target_sect_off, |
| ... | ... | @@ -1629,7 +1670,7 @@ fn relocTargetAddr(self: *Zld, object_id: u16, rel: macho.relocation_info) !u64 |
| 1629 | 1670 | const target_seg = self.load_commands.items[target_mapping.target_seg_id].Segment; |
| 1630 | 1671 | const target_sect = target_seg.sections.items[target_mapping.target_sect_id]; |
| 1631 | 1672 | const target_sect_addr = target_sect.addr + target_mapping.offset; |
| 1632 | | log.debug(" | symbol local to object", .{}); |
| 1673 | log.warn(" | symbol local to object", .{}); |
| 1633 | 1674 | break :blk target_sect_addr + sym.n_value - source_sect.addr; |
| 1634 | 1675 | } else if (isImport(&sym)) { |
| 1635 | 1676 | // Relocate to either the artifact's local symbol, or an import from |
| ... | ... | @@ -2059,6 +2100,18 @@ fn populateMetadata(self: *Zld) !void { |
| 2059 | 2100 | }, |
| 2060 | 2101 | }); |
| 2061 | 2102 | } |
| 2103 | |
| 2104 | if (self.data_in_code_cmd_index == null and self.arch.? == .x86_64) { |
| 2105 | self.data_in_code_cmd_index = @intCast(u16, self.load_commands.items.len); |
| 2106 | try self.load_commands.append(self.allocator, .{ |
| 2107 | .LinkeditData = .{ |
| 2108 | .cmd = macho.LC_DATA_IN_CODE, |
| 2109 | .cmdsize = @sizeOf(macho.linkedit_data_command), |
| 2110 | .dataoff = 0, |
| 2111 | .datasize = 0, |
| 2112 | }, |
| 2113 | }); |
| 2114 | } |
| 2062 | 2115 | } |
| 2063 | 2116 | |
| 2064 | 2117 | fn flush(self: *Zld) !void { |
| ... | ... | @@ -2077,6 +2130,9 @@ fn flush(self: *Zld) !void { |
| 2077 | 2130 | try self.writeBindInfoTable(); |
| 2078 | 2131 | try self.writeLazyBindInfoTable(); |
| 2079 | 2132 | try self.writeExportInfo(); |
| 2133 | if (self.arch.? == .x86_64) { |
| 2134 | try self.writeDataInCode(); |
| 2135 | } |
| 2080 | 2136 | |
| 2081 | 2137 | { |
| 2082 | 2138 | const seg = &self.load_commands.items[self.linkedit_segment_cmd_index.?].Segment; |
| ... | ... | @@ -2169,12 +2225,42 @@ fn writeRebaseInfoTable(self: *Zld) !void { |
| 2169 | 2225 | } |
| 2170 | 2226 | |
| 2171 | 2227 | try pointers.ensureCapacity(pointers.items.len + self.local_rebases.items.len); |
| 2172 | | |
| 2173 | | const nlocals = self.local_rebases.items.len; |
| 2174 | | var i = nlocals; |
| 2175 | | while (i > 0) : (i -= 1) { |
| 2176 | | pointers.appendAssumeCapacity(self.local_rebases.items[i - 1]); |
| 2177 | | } |
| 2228 | pointers.appendSliceAssumeCapacity(self.local_rebases.items); |
| 2229 | |
| 2230 | // const text_seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment; |
| 2231 | // const base_id = text_seg.sections.items.len; |
| 2232 | // for (self.locals.items()) |entry| { |
| 2233 | // for (entry.value.items) |symbol| { |
| 2234 | // const local = symbol.inner; |
| 2235 | |
| 2236 | // if (self.data_const_section_index) |index| { |
| 2237 | // if (local.n_sect == base_id + index) { |
| 2238 | // const offset = local.n_value - data_seg.inner.vmaddr; |
| 2239 | // try pointers.append(.{ |
| 2240 | // .offset = offset, |
| 2241 | // .segment_id = @intCast(u16, self.data_segment_cmd_index.?), |
| 2242 | // }); |
| 2243 | // } |
| 2244 | // } |
| 2245 | // if (self.data_section_index) |index| { |
| 2246 | // if (local.n_sect == base_id + index) { |
| 2247 | // const offset = local.n_value - data_seg.inner.vmaddr; |
| 2248 | // try pointers.append(.{ |
| 2249 | // .offset = offset, |
| 2250 | // .segment_id = @intCast(u16, self.data_segment_cmd_index.?), |
| 2251 | // }); |
| 2252 | // } |
| 2253 | // } |
| 2254 | // } |
| 2255 | // } |
| 2256 | |
| 2257 | std.sort.sort(Pointer, pointers.items, {}, pointerCmp); |
| 2258 | |
| 2259 | // const nlocals = self.local_rebases.items.len; |
| 2260 | // var i = nlocals; |
| 2261 | // while (i > 0) : (i -= 1) { |
| 2262 | // pointers.appendAssumeCapacity(self.local_rebases.items[i - 1]); |
| 2263 | // } |
| 2178 | 2264 | |
| 2179 | 2265 | const size = try rebaseInfoSize(pointers.items); |
| 2180 | 2266 | var buffer = try self.allocator.alloc(u8, @intCast(usize, size)); |
| ... | ... | @@ -2189,11 +2275,19 @@ fn writeRebaseInfoTable(self: *Zld) !void { |
| 2189 | 2275 | dyld_info.rebase_size = @intCast(u32, mem.alignForwardGeneric(u64, buffer.len, @sizeOf(u64))); |
| 2190 | 2276 | seg.inner.filesize += dyld_info.rebase_size; |
| 2191 | 2277 | |
| 2192 | | log.debug("writing rebase info from 0x{x} to 0x{x}", .{ dyld_info.rebase_off, dyld_info.rebase_off + dyld_info.rebase_size }); |
| 2278 | log.warn("writing rebase info from 0x{x} to 0x{x}", .{ dyld_info.rebase_off, dyld_info.rebase_off + dyld_info.rebase_size }); |
| 2193 | 2279 | |
| 2194 | 2280 | try self.file.?.pwriteAll(buffer, dyld_info.rebase_off); |
| 2195 | 2281 | } |
| 2196 | 2282 | |
| 2283 | fn pointerCmp(context: void, a: Pointer, b: Pointer) bool { |
| 2284 | if (a.segment_id < b.segment_id) return true; |
| 2285 | if (a.segment_id == b.segment_id) { |
| 2286 | return a.offset < b.offset; |
| 2287 | } |
| 2288 | return false; |
| 2289 | } |
| 2290 | |
| 2197 | 2291 | fn writeBindInfoTable(self: *Zld) !void { |
| 2198 | 2292 | const data_seg = self.load_commands.items[self.data_segment_cmd_index.?].Segment; |
| 2199 | 2293 | |
| ... | ... | @@ -2242,7 +2336,7 @@ fn writeBindInfoTable(self: *Zld) !void { |
| 2242 | 2336 | dyld_info.bind_size = @intCast(u32, mem.alignForwardGeneric(u64, buffer.len, @alignOf(u64))); |
| 2243 | 2337 | seg.inner.filesize += dyld_info.bind_size; |
| 2244 | 2338 | |
| 2245 | | log.debug("writing binding info from 0x{x} to 0x{x}", .{ dyld_info.bind_off, dyld_info.bind_off + dyld_info.bind_size }); |
| 2339 | log.warn("writing binding info from 0x{x} to 0x{x}", .{ dyld_info.bind_off, dyld_info.bind_off + dyld_info.bind_size }); |
| 2246 | 2340 | |
| 2247 | 2341 | try self.file.?.pwriteAll(buffer, dyld_info.bind_off); |
| 2248 | 2342 | } |
| ... | ... | @@ -2281,7 +2375,7 @@ fn writeLazyBindInfoTable(self: *Zld) !void { |
| 2281 | 2375 | dyld_info.lazy_bind_size = @intCast(u32, mem.alignForwardGeneric(u64, buffer.len, @alignOf(u64))); |
| 2282 | 2376 | seg.inner.filesize += dyld_info.lazy_bind_size; |
| 2283 | 2377 | |
| 2284 | | log.debug("writing lazy binding info from 0x{x} to 0x{x}", .{ dyld_info.lazy_bind_off, dyld_info.lazy_bind_off + dyld_info.lazy_bind_size }); |
| 2378 | log.warn("writing lazy binding info from 0x{x} to 0x{x}", .{ dyld_info.lazy_bind_off, dyld_info.lazy_bind_off + dyld_info.lazy_bind_size }); |
| 2285 | 2379 | |
| 2286 | 2380 | try self.file.?.pwriteAll(buffer, dyld_info.lazy_bind_off); |
| 2287 | 2381 | try self.populateLazyBindOffsetsInStubHelper(buffer); |
| ... | ... | @@ -2383,7 +2477,7 @@ fn writeExportInfo(self: *Zld) !void { |
| 2383 | 2477 | dyld_info.export_size = @intCast(u32, mem.alignForwardGeneric(u64, buffer.len, @alignOf(u64))); |
| 2384 | 2478 | seg.inner.filesize += dyld_info.export_size; |
| 2385 | 2479 | |
| 2386 | | log.debug("writing export info from 0x{x} to 0x{x}", .{ dyld_info.export_off, dyld_info.export_off + dyld_info.export_size }); |
| 2480 | log.warn("writing export info from 0x{x} to 0x{x}", .{ dyld_info.export_off, dyld_info.export_off + dyld_info.export_size }); |
| 2387 | 2481 | |
| 2388 | 2482 | try self.file.?.pwriteAll(buffer, dyld_info.export_off); |
| 2389 | 2483 | } |
| ... | ... | @@ -2517,7 +2611,7 @@ fn writeDebugInfo(self: *Zld) !void { |
| 2517 | 2611 | |
| 2518 | 2612 | const stabs_off = symtab.symoff; |
| 2519 | 2613 | const stabs_size = symtab.nsyms * @sizeOf(macho.nlist_64); |
| 2520 | | log.debug("writing symbol stabs from 0x{x} to 0x{x}", .{ stabs_off, stabs_size + stabs_off }); |
| 2614 | log.warn("writing symbol stabs from 0x{x} to 0x{x}", .{ stabs_off, stabs_size + stabs_off }); |
| 2521 | 2615 | try self.file.?.pwriteAll(mem.sliceAsBytes(stabs.items), stabs_off); |
| 2522 | 2616 | |
| 2523 | 2617 | linkedit.inner.filesize += stabs_size; |
| ... | ... | @@ -2535,12 +2629,12 @@ fn writeSymbolTable(self: *Zld) !void { |
| 2535 | 2629 | defer locals.deinit(); |
| 2536 | 2630 | |
| 2537 | 2631 | for (self.locals.items()) |entries| { |
| 2538 | | log.debug("'{s}': {} entries", .{ entries.key, entries.value.items.len }); |
| 2632 | log.warn("'{s}': {} entries", .{ entries.key, entries.value.items.len }); |
| 2539 | 2633 | // var symbol: ?macho.nlist_64 = null; |
| 2540 | 2634 | for (entries.value.items) |entry| { |
| 2541 | | log.debug(" | {}", .{entry.inner}); |
| 2542 | | log.debug(" | {}", .{entry.tt}); |
| 2543 | | log.debug(" | {s}", .{self.objects.items[entry.object_id].name}); |
| 2635 | log.warn(" | {}", .{entry.inner}); |
| 2636 | log.warn(" | {}", .{entry.tt}); |
| 2637 | log.warn(" | {s}", .{self.objects.items[entry.object_id].name}); |
| 2544 | 2638 | // switch (entry.tt) { |
| 2545 | 2639 | // .Global => { |
| 2546 | 2640 | // symbol = entry.inner; |
| ... | ... | @@ -2585,17 +2679,17 @@ fn writeSymbolTable(self: *Zld) !void { |
| 2585 | 2679 | |
| 2586 | 2680 | const locals_off = symtab.symoff + symtab.nsyms * @sizeOf(macho.nlist_64); |
| 2587 | 2681 | const locals_size = nlocals * @sizeOf(macho.nlist_64); |
| 2588 | | log.debug("writing local symbols from 0x{x} to 0x{x}", .{ locals_off, locals_size + locals_off }); |
| 2682 | log.warn("writing local symbols from 0x{x} to 0x{x}", .{ locals_off, locals_size + locals_off }); |
| 2589 | 2683 | try self.file.?.pwriteAll(mem.sliceAsBytes(locals.items), locals_off); |
| 2590 | 2684 | |
| 2591 | 2685 | const exports_off = locals_off + locals_size; |
| 2592 | 2686 | const exports_size = nexports * @sizeOf(macho.nlist_64); |
| 2593 | | log.debug("writing exported symbols from 0x{x} to 0x{x}", .{ exports_off, exports_size + exports_off }); |
| 2687 | log.warn("writing exported symbols from 0x{x} to 0x{x}", .{ exports_off, exports_size + exports_off }); |
| 2594 | 2688 | try self.file.?.pwriteAll(mem.sliceAsBytes(exports.items), exports_off); |
| 2595 | 2689 | |
| 2596 | 2690 | const undefs_off = exports_off + exports_size; |
| 2597 | 2691 | const undefs_size = nundefs * @sizeOf(macho.nlist_64); |
| 2598 | | log.debug("writing undefined symbols from 0x{x} to 0x{x}", .{ undefs_off, undefs_size + undefs_off }); |
| 2692 | log.warn("writing undefined symbols from 0x{x} to 0x{x}", .{ undefs_off, undefs_size + undefs_off }); |
| 2599 | 2693 | try self.file.?.pwriteAll(mem.sliceAsBytes(undefs.items), undefs_off); |
| 2600 | 2694 | |
| 2601 | 2695 | symtab.nsyms += @intCast(u32, nlocals + nexports + nundefs); |
| ... | ... | @@ -2626,7 +2720,7 @@ fn writeDynamicSymbolTable(self: *Zld) !void { |
| 2626 | 2720 | const needed_size = dysymtab.nindirectsyms * @sizeOf(u32); |
| 2627 | 2721 | seg.inner.filesize += needed_size; |
| 2628 | 2722 | |
| 2629 | | log.debug("writing indirect symbol table from 0x{x} to 0x{x}", .{ |
| 2723 | log.warn("writing indirect symbol table from 0x{x} to 0x{x}", .{ |
| 2630 | 2724 | dysymtab.indirectsymoff, |
| 2631 | 2725 | dysymtab.indirectsymoff + needed_size, |
| 2632 | 2726 | }); |
| ... | ... | @@ -2665,7 +2759,7 @@ fn writeStringTable(self: *Zld) !void { |
| 2665 | 2759 | symtab.strsize = @intCast(u32, mem.alignForwardGeneric(u64, self.strtab.items.len, @alignOf(u64))); |
| 2666 | 2760 | seg.inner.filesize += symtab.strsize; |
| 2667 | 2761 | |
| 2668 | | log.debug("writing string table from 0x{x} to 0x{x}", .{ symtab.stroff, symtab.stroff + symtab.strsize }); |
| 2762 | log.warn("writing string table from 0x{x} to 0x{x}", .{ symtab.stroff, symtab.stroff + symtab.strsize }); |
| 2669 | 2763 | |
| 2670 | 2764 | try self.file.?.pwriteAll(self.strtab.items, symtab.stroff); |
| 2671 | 2765 | |
| ... | ... | @@ -2675,6 +2769,48 @@ fn writeStringTable(self: *Zld) !void { |
| 2675 | 2769 | } |
| 2676 | 2770 | } |
| 2677 | 2771 | |
| 2772 | fn writeDataInCode(self: *Zld) !void { |
| 2773 | const seg = &self.load_commands.items[self.linkedit_segment_cmd_index.?].Segment; |
| 2774 | const dice_cmd = &self.load_commands.items[self.data_in_code_cmd_index.?].LinkeditData; |
| 2775 | const fileoff = seg.inner.fileoff + seg.inner.filesize; |
| 2776 | |
| 2777 | var buf = std.ArrayList(u8).init(self.allocator); |
| 2778 | defer buf.deinit(); |
| 2779 | |
| 2780 | const text_seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment; |
| 2781 | const text_sect = text_seg.sections.items[self.text_section_index.?]; |
| 2782 | for (self.objects.items) |object, object_id| { |
| 2783 | const source_seg = object.load_commands.items[object.segment_cmd_index.?].Segment; |
| 2784 | const source_sect = source_seg.sections.items[object.text_section_index.?]; |
| 2785 | const target_mapping = self.mappings.get(.{ |
| 2786 | .object_id = @intCast(u16, object_id), |
| 2787 | .source_sect_id = object.text_section_index.?, |
| 2788 | }) orelse continue; |
| 2789 | |
| 2790 | // TODO Currently assume that Dice will always be within the __TEXT,__text section. |
| 2791 | try buf.ensureCapacity( |
| 2792 | buf.items.len + object.data_in_code_entries.items.len * @sizeOf(macho.data_in_code_entry), |
| 2793 | ); |
| 2794 | for (object.data_in_code_entries.items) |dice| { |
| 2795 | const new_dice: macho.data_in_code_entry = .{ |
| 2796 | .offset = text_sect.offset + target_mapping.offset + dice.offset - source_sect.offset, |
| 2797 | .length = dice.length, |
| 2798 | .kind = dice.kind, |
| 2799 | }; |
| 2800 | buf.appendSliceAssumeCapacity(mem.asBytes(&new_dice)); |
| 2801 | } |
| 2802 | } |
| 2803 | const datasize = @intCast(u32, buf.items.len); |
| 2804 | |
| 2805 | dice_cmd.dataoff = @intCast(u32, fileoff); |
| 2806 | dice_cmd.datasize = datasize; |
| 2807 | seg.inner.filesize += datasize; |
| 2808 | |
| 2809 | log.warn("writing data-in-code from 0x{x} to 0x{x}", .{ fileoff, fileoff + datasize }); |
| 2810 | |
| 2811 | try self.file.?.pwriteAll(buf.items, fileoff); |
| 2812 | } |
| 2813 | |
| 2678 | 2814 | fn writeCodeSignaturePadding(self: *Zld) !void { |
| 2679 | 2815 | const seg = &self.load_commands.items[self.linkedit_segment_cmd_index.?].Segment; |
| 2680 | 2816 | const code_sig_cmd = &self.load_commands.items[self.code_signature_cmd_index.?].LinkeditData; |
| ... | ... | @@ -2691,7 +2827,7 @@ fn writeCodeSignaturePadding(self: *Zld) !void { |
| 2691 | 2827 | seg.inner.filesize += needed_size; |
| 2692 | 2828 | seg.inner.vmsize = mem.alignForwardGeneric(u64, seg.inner.filesize, self.page_size.?); |
| 2693 | 2829 | |
| 2694 | | log.debug("writing code signature padding from 0x{x} to 0x{x}", .{ fileoff, fileoff + needed_size }); |
| 2830 | log.warn("writing code signature padding from 0x{x} to 0x{x}", .{ fileoff, fileoff + needed_size }); |
| 2695 | 2831 | |
| 2696 | 2832 | // Pad out the space. We need to do this to calculate valid hashes for everything in the file |
| 2697 | 2833 | // except for code signature data. |
| ... | ... | @@ -2717,7 +2853,7 @@ fn writeCodeSignature(self: *Zld) !void { |
| 2717 | 2853 | var stream = std.io.fixedBufferStream(buffer); |
| 2718 | 2854 | try code_sig.write(stream.writer()); |
| 2719 | 2855 | |
| 2720 | | log.debug("writing code signature from 0x{x} to 0x{x}", .{ code_sig_cmd.dataoff, code_sig_cmd.dataoff + buffer.len }); |
| 2856 | log.warn("writing code signature from 0x{x} to 0x{x}", .{ code_sig_cmd.dataoff, code_sig_cmd.dataoff + buffer.len }); |
| 2721 | 2857 | |
| 2722 | 2858 | try self.file.?.pwriteAll(buffer, code_sig_cmd.dataoff); |
| 2723 | 2859 | } |
| ... | ... | @@ -2736,7 +2872,7 @@ fn writeLoadCommands(self: *Zld) !void { |
| 2736 | 2872 | } |
| 2737 | 2873 | |
| 2738 | 2874 | const off = @sizeOf(macho.mach_header_64); |
| 2739 | | log.debug("writing {} load commands from 0x{x} to 0x{x}", .{ self.load_commands.items.len, off, off + sizeofcmds }); |
| 2875 | log.warn("writing {} load commands from 0x{x} to 0x{x}", .{ self.load_commands.items.len, off, off + sizeofcmds }); |
| 2740 | 2876 | try self.file.?.pwriteAll(buffer, off); |
| 2741 | 2877 | } |
| 2742 | 2878 | |
| ... | ... | @@ -2774,7 +2910,7 @@ fn writeHeader(self: *Zld) !void { |
| 2774 | 2910 | for (self.load_commands.items) |cmd| { |
| 2775 | 2911 | header.sizeofcmds += cmd.cmdsize(); |
| 2776 | 2912 | } |
| 2777 | | log.debug("writing Mach-O header {}", .{header}); |
| 2913 | log.warn("writing Mach-O header {}", .{header}); |
| 2778 | 2914 | try self.file.?.pwriteAll(mem.asBytes(&header), 0); |
| 2779 | 2915 | } |
| 2780 | 2916 | |
| ... | ... | @@ -2788,7 +2924,7 @@ pub fn makeStaticString(bytes: []const u8) [16]u8 { |
| 2788 | 2924 | fn makeString(self: *Zld, bytes: []const u8) !u32 { |
| 2789 | 2925 | try self.strtab.ensureCapacity(self.allocator, self.strtab.items.len + bytes.len + 1); |
| 2790 | 2926 | const offset = @intCast(u32, self.strtab.items.len); |
| 2791 | | log.debug("writing new string '{s}' into string table at offset 0x{x}", .{ bytes, offset }); |
| 2927 | log.warn("writing new string '{s}' into string table at offset 0x{x}", .{ bytes, offset }); |
| 2792 | 2928 | self.strtab.appendSliceAssumeCapacity(bytes); |
| 2793 | 2929 | self.strtab.appendAssumeCapacity(0); |
| 2794 | 2930 | return offset; |
Jakub Konka <kubkon@jakubkonka.com> 2021-03-03 01:52:21+01:00