| ... | ... | @@ -66,7 +66,7 @@ const Section = struct { |
| 66 | 66 | |
| 67 | 67 | // TODO is null here necessary, or can we do away with tracking via section |
| 68 | 68 | // size in incremental context? |
| 69 | | last_atom: ?*Atom = null, |
| 69 | last_atom_index: ?Atom.Index = null, |
| 70 | 70 | |
| 71 | 71 | /// A list of atoms that have surplus capacity. This list can have false |
| 72 | 72 | /// positives, as functions grow and shrink over time, only sometimes being added |
| ... | ... | @@ -83,7 +83,7 @@ const Section = struct { |
| 83 | 83 | /// overcapacity can be negative. A simple way to have negative overcapacity is to |
| 84 | 84 | /// allocate a fresh atom, which will have ideal capacity, and then grow it |
| 85 | 85 | /// by 1 byte. It will then have -1 overcapacity. |
| 86 | | free_list: std.ArrayListUnmanaged(*Atom) = .{}, |
| 86 | free_list: std.ArrayListUnmanaged(Atom.Index) = .{}, |
| 87 | 87 | }; |
| 88 | 88 | |
| 89 | 89 | base: File, |
| ... | ... | @@ -140,8 +140,8 @@ locals_free_list: std.ArrayListUnmanaged(u32) = .{}, |
| 140 | 140 | globals_free_list: std.ArrayListUnmanaged(u32) = .{}, |
| 141 | 141 | |
| 142 | 142 | dyld_stub_binder_index: ?u32 = null, |
| 143 | | dyld_private_atom: ?*Atom = null, |
| 144 | | stub_helper_preamble_atom: ?*Atom = null, |
| 143 | dyld_private_atom_index: ?Atom.Index = null, |
| 144 | stub_helper_preamble_atom_index: ?Atom.Index = null, |
| 145 | 145 | |
| 146 | 146 | strtab: StringTable(.strtab) = .{}, |
| 147 | 147 | |
| ... | ... | @@ -164,10 +164,10 @@ segment_table_dirty: bool = false, |
| 164 | 164 | cold_start: bool = true, |
| 165 | 165 | |
| 166 | 166 | /// List of atoms that are either synthetic or map directly to the Zig source program. |
| 167 | | managed_atoms: std.ArrayListUnmanaged(*Atom) = .{}, |
| 167 | atoms: std.ArrayListUnmanaged(Atom) = .{}, |
| 168 | 168 | |
| 169 | 169 | /// Table of atoms indexed by the symbol index. |
| 170 | | atom_by_index_table: std.AutoHashMapUnmanaged(u32, *Atom) = .{}, |
| 170 | atom_by_index_table: std.AutoHashMapUnmanaged(u32, Atom.Index) = .{}, |
| 171 | 171 | |
| 172 | 172 | /// Table of unnamed constants associated with a parent `Decl`. |
| 173 | 173 | /// We store them here so that we can free the constants whenever the `Decl` |
| ... | ... | @@ -210,11 +210,36 @@ bindings: BindingTable = .{}, |
| 210 | 210 | /// this will be a table indexed by index into the list of Atoms. |
| 211 | 211 | lazy_bindings: BindingTable = .{}, |
| 212 | 212 | |
| 213 | | /// Table of Decls that are currently alive. |
| 214 | | /// We store them here so that we can properly dispose of any allocated |
| 215 | | /// memory within the atom in the incremental linker. |
| 216 | | /// TODO consolidate this. |
| 217 | | decls: std.AutoArrayHashMapUnmanaged(Module.Decl.Index, ?u8) = .{}, |
| 213 | /// Table of tracked Decls. |
| 214 | decls: std.AutoArrayHashMapUnmanaged(Module.Decl.Index, DeclMetadata) = .{}, |
| 215 | |
| 216 | const DeclMetadata = struct { |
| 217 | atom: Atom.Index, |
| 218 | section: u8, |
| 219 | /// A list of all exports aliases of this Decl. |
| 220 | /// TODO do we actually need this at all? |
| 221 | exports: std.ArrayListUnmanaged(u32) = .{}, |
| 222 | |
| 223 | fn getExport(m: DeclMetadata, macho_file: *const MachO, name: []const u8) ?u32 { |
| 224 | for (m.exports.items) |exp| { |
| 225 | if (mem.eql(u8, name, macho_file.getSymbolName(.{ |
| 226 | .sym_index = exp, |
| 227 | .file = null, |
| 228 | }))) return exp; |
| 229 | } |
| 230 | return null; |
| 231 | } |
| 232 | |
| 233 | fn getExportPtr(m: *DeclMetadata, macho_file: *MachO, name: []const u8) ?*u32 { |
| 234 | for (m.exports.items) |*exp| { |
| 235 | if (mem.eql(u8, name, macho_file.getSymbolName(.{ |
| 236 | .sym_index = exp.*, |
| 237 | .file = null, |
| 238 | }))) return exp; |
| 239 | } |
| 240 | return null; |
| 241 | } |
| 242 | }; |
| 218 | 243 | |
| 219 | 244 | const Entry = struct { |
| 220 | 245 | target: SymbolWithLoc, |
| ... | ... | @@ -229,8 +254,8 @@ const Entry = struct { |
| 229 | 254 | return macho_file.getSymbolPtr(.{ .sym_index = entry.sym_index, .file = null }); |
| 230 | 255 | } |
| 231 | 256 | |
| 232 | | pub fn getAtom(entry: Entry, macho_file: *MachO) ?*Atom { |
| 233 | | return macho_file.getAtomForSymbol(.{ .sym_index = entry.sym_index, .file = null }); |
| 257 | pub fn getAtomIndex(entry: Entry, macho_file: *MachO) ?Atom.Index { |
| 258 | return macho_file.getAtomIndexForSymbol(.{ .sym_index = entry.sym_index, .file = null }); |
| 234 | 259 | } |
| 235 | 260 | |
| 236 | 261 | pub fn getName(entry: Entry, macho_file: *MachO) []const u8 { |
| ... | ... | @@ -238,10 +263,10 @@ const Entry = struct { |
| 238 | 263 | } |
| 239 | 264 | }; |
| 240 | 265 | |
| 241 | | const BindingTable = std.AutoArrayHashMapUnmanaged(*Atom, std.ArrayListUnmanaged(Atom.Binding)); |
| 242 | | const UnnamedConstTable = std.AutoArrayHashMapUnmanaged(Module.Decl.Index, std.ArrayListUnmanaged(*Atom)); |
| 243 | | const RebaseTable = std.AutoArrayHashMapUnmanaged(*Atom, std.ArrayListUnmanaged(u32)); |
| 244 | | const RelocationTable = std.AutoArrayHashMapUnmanaged(*Atom, std.ArrayListUnmanaged(Relocation)); |
| 266 | const BindingTable = std.AutoArrayHashMapUnmanaged(Atom.Index, std.ArrayListUnmanaged(Atom.Binding)); |
| 267 | const UnnamedConstTable = std.AutoArrayHashMapUnmanaged(Module.Decl.Index, std.ArrayListUnmanaged(Atom.Index)); |
| 268 | const RebaseTable = std.AutoArrayHashMapUnmanaged(Atom.Index, std.ArrayListUnmanaged(u32)); |
| 269 | const RelocationTable = std.AutoArrayHashMapUnmanaged(Atom.Index, std.ArrayListUnmanaged(Relocation)); |
| 245 | 270 | |
| 246 | 271 | const PendingUpdate = union(enum) { |
| 247 | 272 | resolve_undef: u32, |
| ... | ... | @@ -286,10 +311,6 @@ pub const default_pagezero_vmsize: u64 = 0x100000000; |
| 286 | 311 | /// potential future extensions. |
| 287 | 312 | pub const default_headerpad_size: u32 = 0x1000; |
| 288 | 313 | |
| 289 | | pub const Export = struct { |
| 290 | | sym_index: ?u32 = null, |
| 291 | | }; |
| 292 | | |
| 293 | 314 | pub fn openPath(allocator: Allocator, options: link.Options) !*MachO { |
| 294 | 315 | assert(options.target.ofmt == .macho); |
| 295 | 316 | |
| ... | ... | @@ -451,9 +472,9 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No |
| 451 | 472 | |
| 452 | 473 | const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented; |
| 453 | 474 | |
| 454 | | if (self.d_sym) |*d_sym| { |
| 455 | | try d_sym.dwarf.flushModule(module); |
| 456 | | } |
| 475 | // if (self.d_sym) |*d_sym| { |
| 476 | // try d_sym.dwarf.flushModule(module); |
| 477 | // } |
| 457 | 478 | |
| 458 | 479 | var libs = std.StringArrayHashMap(link.SystemLib).init(arena); |
| 459 | 480 | try resolveLibSystem( |
| ... | ... | @@ -547,8 +568,8 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No |
| 547 | 568 | |
| 548 | 569 | try self.allocateSpecialSymbols(); |
| 549 | 570 | |
| 550 | | for (self.relocs.keys()) |atom| { |
| 551 | | try atom.resolveRelocations(self); |
| 571 | for (self.relocs.keys()) |atom_index| { |
| 572 | try Atom.resolveRelocations(self, atom_index); |
| 552 | 573 | } |
| 553 | 574 | |
| 554 | 575 | if (build_options.enable_logging) { |
| ... | ... | @@ -643,10 +664,10 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No |
| 643 | 664 | try self.writeCodeSignature(comp, csig); // code signing always comes last |
| 644 | 665 | } |
| 645 | 666 | |
| 646 | | if (self.d_sym) |*d_sym| { |
| 647 | | // Flush debug symbols bundle. |
| 648 | | try d_sym.flushModule(self); |
| 649 | | } |
| 667 | // if (self.d_sym) |*d_sym| { |
| 668 | // // Flush debug symbols bundle. |
| 669 | // try d_sym.flushModule(self); |
| 670 | // } |
| 650 | 671 | |
| 651 | 672 | // if (build_options.enable_link_snapshots) { |
| 652 | 673 | // if (self.base.options.enable_link_snapshots) |
| ... | ... | @@ -999,18 +1020,19 @@ pub fn parseDependentLibs(self: *MachO, syslibroot: ?[]const u8, dependent_libs: |
| 999 | 1020 | } |
| 1000 | 1021 | } |
| 1001 | 1022 | |
| 1002 | | pub fn writeAtom(self: *MachO, atom: *Atom, code: []const u8) !void { |
| 1023 | pub fn writeAtom(self: *MachO, atom_index: Atom.Index, code: []const u8) !void { |
| 1024 | const atom = self.getAtom(atom_index); |
| 1003 | 1025 | const sym = atom.getSymbol(self); |
| 1004 | 1026 | const section = self.sections.get(sym.n_sect - 1); |
| 1005 | 1027 | const file_offset = section.header.offset + sym.n_value - section.header.addr; |
| 1006 | 1028 | log.debug("writing atom for symbol {s} at file offset 0x{x}", .{ atom.getName(self), file_offset }); |
| 1007 | 1029 | try self.base.file.?.pwriteAll(code, file_offset); |
| 1008 | | try atom.resolveRelocations(self); |
| 1030 | try Atom.resolveRelocations(self, atom_index); |
| 1009 | 1031 | } |
| 1010 | 1032 | |
| 1011 | | fn writePtrWidthAtom(self: *MachO, atom: *Atom) !void { |
| 1033 | fn writePtrWidthAtom(self: *MachO, atom_index: Atom.Index) !void { |
| 1012 | 1034 | var buffer: [@sizeOf(u64)]u8 = [_]u8{0} ** @sizeOf(u64); |
| 1013 | | try self.writeAtom(atom, &buffer); |
| 1035 | try self.writeAtom(atom_index, &buffer); |
| 1014 | 1036 | } |
| 1015 | 1037 | |
| 1016 | 1038 | fn markRelocsDirtyByTarget(self: *MachO, target: SymbolWithLoc) void { |
| ... | ... | @@ -1026,7 +1048,8 @@ fn markRelocsDirtyByTarget(self: *MachO, target: SymbolWithLoc) void { |
| 1026 | 1048 | fn markRelocsDirtyByAddress(self: *MachO, addr: u64) void { |
| 1027 | 1049 | for (self.relocs.values()) |*relocs| { |
| 1028 | 1050 | for (relocs.items) |*reloc| { |
| 1029 | | const target_atom = reloc.getTargetAtom(self) orelse continue; |
| 1051 | const target_atom_index = reloc.getTargetAtomIndex(self) orelse continue; |
| 1052 | const target_atom = self.getAtom(target_atom_index); |
| 1030 | 1053 | const target_sym = target_atom.getSymbol(self); |
| 1031 | 1054 | if (target_sym.n_value < addr) continue; |
| 1032 | 1055 | reloc.dirty = true; |
| ... | ... | @@ -1053,26 +1076,39 @@ pub fn allocateSpecialSymbols(self: *MachO) !void { |
| 1053 | 1076 | } |
| 1054 | 1077 | } |
| 1055 | 1078 | |
| 1056 | | pub fn createGotAtom(self: *MachO, target: SymbolWithLoc) !*Atom { |
| 1079 | pub fn createAtom(self: *MachO) !Atom.Index { |
| 1057 | 1080 | const gpa = self.base.allocator; |
| 1081 | const atom_index = @intCast(Atom.Index, self.atoms.items.len); |
| 1082 | const atom = try self.atoms.addOne(gpa); |
| 1083 | const sym_index = try self.allocateSymbol(); |
| 1084 | try self.atom_by_index_table.putNoClobber(gpa, sym_index, atom_index); |
| 1085 | atom.* = .{ |
| 1086 | .sym_index = sym_index, |
| 1087 | .file = null, |
| 1088 | .size = 0, |
| 1089 | .alignment = 0, |
| 1090 | .prev_index = null, |
| 1091 | .next_index = null, |
| 1092 | .dbg_info_atom = undefined, |
| 1093 | }; |
| 1094 | log.debug("creating ATOM(%{d}) at index {d}", .{ sym_index, atom_index }); |
| 1095 | return atom_index; |
| 1096 | } |
| 1058 | 1097 | |
| 1059 | | const atom = try gpa.create(Atom); |
| 1060 | | atom.* = Atom.empty; |
| 1061 | | try atom.ensureInitialized(self); |
| 1098 | pub fn createGotAtom(self: *MachO, target: SymbolWithLoc) !Atom.Index { |
| 1099 | const atom_index = try self.createAtom(); |
| 1100 | const atom = self.getAtomPtr(atom_index); |
| 1062 | 1101 | atom.size = @sizeOf(u64); |
| 1063 | 1102 | atom.alignment = @alignOf(u64); |
| 1064 | | errdefer gpa.destroy(atom); |
| 1065 | | |
| 1066 | | try self.managed_atoms.append(gpa, atom); |
| 1067 | 1103 | |
| 1068 | 1104 | const sym = atom.getSymbolPtr(self); |
| 1069 | 1105 | sym.n_type = macho.N_SECT; |
| 1070 | 1106 | sym.n_sect = self.got_section_index.? + 1; |
| 1071 | | sym.n_value = try self.allocateAtom(atom, atom.size, @alignOf(u64)); |
| 1107 | sym.n_value = try self.allocateAtom(atom_index, atom.size, @alignOf(u64)); |
| 1072 | 1108 | |
| 1073 | 1109 | log.debug("allocated GOT atom at 0x{x}", .{sym.n_value}); |
| 1074 | 1110 | |
| 1075 | | try atom.addRelocation(self, .{ |
| 1111 | try Atom.addRelocation(self, atom_index, .{ |
| 1076 | 1112 | .type = switch (self.base.options.target.cpu.arch) { |
| 1077 | 1113 | .aarch64 => @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_UNSIGNED), |
| 1078 | 1114 | .x86_64 => @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_UNSIGNED), |
| ... | ... | @@ -1087,45 +1123,39 @@ pub fn createGotAtom(self: *MachO, target: SymbolWithLoc) !*Atom { |
| 1087 | 1123 | |
| 1088 | 1124 | const target_sym = self.getSymbol(target); |
| 1089 | 1125 | if (target_sym.undf()) { |
| 1090 | | try atom.addBinding(self, .{ |
| 1126 | try Atom.addBinding(self, atom_index, .{ |
| 1091 | 1127 | .target = self.getGlobal(self.getSymbolName(target)).?, |
| 1092 | 1128 | .offset = 0, |
| 1093 | 1129 | }); |
| 1094 | 1130 | } else { |
| 1095 | | try atom.addRebase(self, 0); |
| 1131 | try Atom.addRebase(self, atom_index, 0); |
| 1096 | 1132 | } |
| 1097 | 1133 | |
| 1098 | | return atom; |
| 1134 | return atom_index; |
| 1099 | 1135 | } |
| 1100 | 1136 | |
| 1101 | 1137 | pub fn createDyldPrivateAtom(self: *MachO) !void { |
| 1102 | 1138 | if (self.dyld_stub_binder_index == null) return; |
| 1103 | | if (self.dyld_private_atom != null) return; |
| 1139 | if (self.dyld_private_atom_index != null) return; |
| 1104 | 1140 | |
| 1105 | | const gpa = self.base.allocator; |
| 1106 | | |
| 1107 | | const atom = try gpa.create(Atom); |
| 1108 | | atom.* = Atom.empty; |
| 1109 | | try atom.ensureInitialized(self); |
| 1141 | const atom_index = try self.createAtom(); |
| 1142 | const atom = self.getAtomPtr(atom_index); |
| 1110 | 1143 | atom.size = @sizeOf(u64); |
| 1111 | 1144 | atom.alignment = @alignOf(u64); |
| 1112 | | errdefer gpa.destroy(atom); |
| 1113 | 1145 | |
| 1114 | 1146 | const sym = atom.getSymbolPtr(self); |
| 1115 | 1147 | sym.n_type = macho.N_SECT; |
| 1116 | 1148 | sym.n_sect = self.data_section_index.? + 1; |
| 1117 | | self.dyld_private_atom = atom; |
| 1118 | | |
| 1119 | | try self.managed_atoms.append(gpa, atom); |
| 1149 | self.dyld_private_atom_index = atom_index; |
| 1120 | 1150 | |
| 1121 | | sym.n_value = try self.allocateAtom(atom, atom.size, @alignOf(u64)); |
| 1151 | sym.n_value = try self.allocateAtom(atom_index, atom.size, @alignOf(u64)); |
| 1122 | 1152 | log.debug("allocated dyld_private atom at 0x{x}", .{sym.n_value}); |
| 1123 | | try self.writePtrWidthAtom(atom); |
| 1153 | try self.writePtrWidthAtom(atom_index); |
| 1124 | 1154 | } |
| 1125 | 1155 | |
| 1126 | 1156 | pub fn createStubHelperPreambleAtom(self: *MachO) !void { |
| 1127 | 1157 | if (self.dyld_stub_binder_index == null) return; |
| 1128 | | if (self.stub_helper_preamble_atom != null) return; |
| 1158 | if (self.stub_helper_preamble_atom_index != null) return; |
| 1129 | 1159 | |
| 1130 | 1160 | const gpa = self.base.allocator; |
| 1131 | 1161 | const arch = self.base.options.target.cpu.arch; |
| ... | ... | @@ -1134,22 +1164,23 @@ pub fn createStubHelperPreambleAtom(self: *MachO) !void { |
| 1134 | 1164 | .aarch64 => 6 * @sizeOf(u32), |
| 1135 | 1165 | else => unreachable, |
| 1136 | 1166 | }; |
| 1137 | | const atom = try gpa.create(Atom); |
| 1138 | | atom.* = Atom.empty; |
| 1139 | | try atom.ensureInitialized(self); |
| 1167 | const atom_index = try self.createAtom(); |
| 1168 | const atom = self.getAtomPtr(atom_index); |
| 1140 | 1169 | atom.size = size; |
| 1141 | 1170 | atom.alignment = switch (arch) { |
| 1142 | 1171 | .x86_64 => 1, |
| 1143 | 1172 | .aarch64 => @alignOf(u32), |
| 1144 | 1173 | else => unreachable, |
| 1145 | 1174 | }; |
| 1146 | | errdefer gpa.destroy(atom); |
| 1147 | 1175 | |
| 1148 | 1176 | const sym = atom.getSymbolPtr(self); |
| 1149 | 1177 | sym.n_type = macho.N_SECT; |
| 1150 | 1178 | sym.n_sect = self.stub_helper_section_index.? + 1; |
| 1151 | 1179 | |
| 1152 | | const dyld_private_sym_index = self.dyld_private_atom.?.getSymbolIndex().?; |
| 1180 | const dyld_private_sym_index = if (self.dyld_private_atom_index) |dyld_index| |
| 1181 | self.getAtom(dyld_index).getSymbolIndex().? |
| 1182 | else |
| 1183 | unreachable; |
| 1153 | 1184 | |
| 1154 | 1185 | const code = try gpa.alloc(u8, size); |
| 1155 | 1186 | defer gpa.free(code); |
| ... | ... | @@ -1168,7 +1199,7 @@ pub fn createStubHelperPreambleAtom(self: *MachO) !void { |
| 1168 | 1199 | code[9] = 0xff; |
| 1169 | 1200 | code[10] = 0x25; |
| 1170 | 1201 | |
| 1171 | | try atom.addRelocations(self, 2, .{ .{ |
| 1202 | try Atom.addRelocations(self, atom_index, 2, .{ .{ |
| 1172 | 1203 | .type = @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_SIGNED), |
| 1173 | 1204 | .target = .{ .sym_index = dyld_private_sym_index, .file = null }, |
| 1174 | 1205 | .offset = 3, |
| ... | ... | @@ -1208,7 +1239,7 @@ pub fn createStubHelperPreambleAtom(self: *MachO) !void { |
| 1208 | 1239 | // br x16 |
| 1209 | 1240 | mem.writeIntLittle(u32, code[20..][0..4], aarch64.Instruction.br(.x16).toU32()); |
| 1210 | 1241 | |
| 1211 | | try atom.addRelocations(self, 4, .{ .{ |
| 1242 | try Atom.addRelocations(self, atom_index, 4, .{ .{ |
| 1212 | 1243 | .type = @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_PAGE21), |
| 1213 | 1244 | .target = .{ .sym_index = dyld_private_sym_index, .file = null }, |
| 1214 | 1245 | .offset = 0, |
| ... | ... | @@ -1241,16 +1272,14 @@ pub fn createStubHelperPreambleAtom(self: *MachO) !void { |
| 1241 | 1272 | |
| 1242 | 1273 | else => unreachable, |
| 1243 | 1274 | } |
| 1244 | | self.stub_helper_preamble_atom = atom; |
| 1275 | self.stub_helper_preamble_atom_index = atom_index; |
| 1245 | 1276 | |
| 1246 | | try self.managed_atoms.append(gpa, atom); |
| 1247 | | |
| 1248 | | sym.n_value = try self.allocateAtom(atom, size, atom.alignment); |
| 1277 | sym.n_value = try self.allocateAtom(atom_index, size, atom.alignment); |
| 1249 | 1278 | log.debug("allocated stub preamble atom at 0x{x}", .{sym.n_value}); |
| 1250 | | try self.writeAtom(atom, code); |
| 1279 | try self.writeAtom(atom_index, code); |
| 1251 | 1280 | } |
| 1252 | 1281 | |
| 1253 | | pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1282 | pub fn createStubHelperAtom(self: *MachO) !Atom.Index { |
| 1254 | 1283 | const gpa = self.base.allocator; |
| 1255 | 1284 | const arch = self.base.options.target.cpu.arch; |
| 1256 | 1285 | const size: u4 = switch (arch) { |
| ... | ... | @@ -1258,16 +1287,14 @@ pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1258 | 1287 | .aarch64 => 3 * @sizeOf(u32), |
| 1259 | 1288 | else => unreachable, |
| 1260 | 1289 | }; |
| 1261 | | const atom = try gpa.create(Atom); |
| 1262 | | atom.* = Atom.empty; |
| 1263 | | try atom.ensureInitialized(self); |
| 1290 | const atom_index = try self.createAtom(); |
| 1291 | const atom = self.getAtomPtr(atom_index); |
| 1264 | 1292 | atom.size = size; |
| 1265 | 1293 | atom.alignment = switch (arch) { |
| 1266 | 1294 | .x86_64 => 1, |
| 1267 | 1295 | .aarch64 => @alignOf(u32), |
| 1268 | 1296 | else => unreachable, |
| 1269 | 1297 | }; |
| 1270 | | errdefer gpa.destroy(atom); |
| 1271 | 1298 | |
| 1272 | 1299 | const sym = atom.getSymbolPtr(self); |
| 1273 | 1300 | sym.n_type = macho.N_SECT; |
| ... | ... | @@ -1277,6 +1304,11 @@ pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1277 | 1304 | defer gpa.free(code); |
| 1278 | 1305 | mem.set(u8, code, 0); |
| 1279 | 1306 | |
| 1307 | const stub_helper_preamble_atom_sym_index = if (self.stub_helper_preamble_atom_index) |stub_index| |
| 1308 | self.getAtom(stub_index).getSymbolIndex().? |
| 1309 | else |
| 1310 | unreachable; |
| 1311 | |
| 1280 | 1312 | switch (arch) { |
| 1281 | 1313 | .x86_64 => { |
| 1282 | 1314 | // pushq |
| ... | ... | @@ -1285,9 +1317,9 @@ pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1285 | 1317 | // jmpq |
| 1286 | 1318 | code[5] = 0xe9; |
| 1287 | 1319 | |
| 1288 | | try atom.addRelocation(self, .{ |
| 1320 | try Atom.addRelocation(self, atom_index, .{ |
| 1289 | 1321 | .type = @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_BRANCH), |
| 1290 | | .target = .{ .sym_index = self.stub_helper_preamble_atom.?.getSymbolIndex().?, .file = null }, |
| 1322 | .target = .{ .sym_index = stub_helper_preamble_atom_sym_index, .file = null }, |
| 1291 | 1323 | .offset = 6, |
| 1292 | 1324 | .addend = 0, |
| 1293 | 1325 | .pcrel = true, |
| ... | ... | @@ -1308,9 +1340,9 @@ pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1308 | 1340 | mem.writeIntLittle(u32, code[4..8], aarch64.Instruction.b(0).toU32()); |
| 1309 | 1341 | // Next 4 bytes 8..12 are just a placeholder populated in `populateLazyBindOffsetsInStubHelper`. |
| 1310 | 1342 | |
| 1311 | | try atom.addRelocation(self, .{ |
| 1343 | try Atom.addRelocation(self, atom_index, .{ |
| 1312 | 1344 | .type = @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_BRANCH26), |
| 1313 | | .target = .{ .sym_index = self.stub_helper_preamble_atom.?.getSymbolIndex().?, .file = null }, |
| 1345 | .target = .{ .sym_index = stub_helper_preamble_atom_sym_index, .file = null }, |
| 1314 | 1346 | .offset = 4, |
| 1315 | 1347 | .addend = 0, |
| 1316 | 1348 | .pcrel = true, |
| ... | ... | @@ -1320,29 +1352,24 @@ pub fn createStubHelperAtom(self: *MachO) !*Atom { |
| 1320 | 1352 | else => unreachable, |
| 1321 | 1353 | } |
| 1322 | 1354 | |
| 1323 | | try self.managed_atoms.append(gpa, atom); |
| 1324 | | |
| 1325 | | sym.n_value = try self.allocateAtom(atom, size, atom.alignment); |
| 1355 | sym.n_value = try self.allocateAtom(atom_index, size, atom.alignment); |
| 1326 | 1356 | log.debug("allocated stub helper atom at 0x{x}", .{sym.n_value}); |
| 1327 | | try self.writeAtom(atom, code); |
| 1357 | try self.writeAtom(atom_index, code); |
| 1328 | 1358 | |
| 1329 | | return atom; |
| 1359 | return atom_index; |
| 1330 | 1360 | } |
| 1331 | 1361 | |
| 1332 | | pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, target: SymbolWithLoc) !*Atom { |
| 1333 | | const gpa = self.base.allocator; |
| 1334 | | const atom = try gpa.create(Atom); |
| 1335 | | atom.* = Atom.empty; |
| 1336 | | try atom.ensureInitialized(self); |
| 1362 | pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, target: SymbolWithLoc) !Atom.Index { |
| 1363 | const atom_index = try self.createAtom(); |
| 1364 | const atom = self.getAtomPtr(atom_index); |
| 1337 | 1365 | atom.size = @sizeOf(u64); |
| 1338 | 1366 | atom.alignment = @alignOf(u64); |
| 1339 | | errdefer gpa.destroy(atom); |
| 1340 | 1367 | |
| 1341 | 1368 | const sym = atom.getSymbolPtr(self); |
| 1342 | 1369 | sym.n_type = macho.N_SECT; |
| 1343 | 1370 | sym.n_sect = self.la_symbol_ptr_section_index.? + 1; |
| 1344 | 1371 | |
| 1345 | | try atom.addRelocation(self, .{ |
| 1372 | try Atom.addRelocation(self, atom_index, .{ |
| 1346 | 1373 | .type = switch (self.base.options.target.cpu.arch) { |
| 1347 | 1374 | .aarch64 => @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_UNSIGNED), |
| 1348 | 1375 | .x86_64 => @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_UNSIGNED), |
| ... | ... | @@ -1354,22 +1381,20 @@ pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, target: SymbolWi |
| 1354 | 1381 | .pcrel = false, |
| 1355 | 1382 | .length = 3, |
| 1356 | 1383 | }); |
| 1357 | | try atom.addRebase(self, 0); |
| 1358 | | try atom.addLazyBinding(self, .{ |
| 1384 | try Atom.addRebase(self, atom_index, 0); |
| 1385 | try Atom.addLazyBinding(self, atom_index, .{ |
| 1359 | 1386 | .target = self.getGlobal(self.getSymbolName(target)).?, |
| 1360 | 1387 | .offset = 0, |
| 1361 | 1388 | }); |
| 1362 | 1389 | |
| 1363 | | try self.managed_atoms.append(gpa, atom); |
| 1364 | | |
| 1365 | | sym.n_value = try self.allocateAtom(atom, atom.size, @alignOf(u64)); |
| 1390 | sym.n_value = try self.allocateAtom(atom_index, atom.size, @alignOf(u64)); |
| 1366 | 1391 | log.debug("allocated lazy pointer atom at 0x{x} ({s})", .{ sym.n_value, self.getSymbolName(target) }); |
| 1367 | | try self.writePtrWidthAtom(atom); |
| 1392 | try self.writePtrWidthAtom(atom_index); |
| 1368 | 1393 | |
| 1369 | | return atom; |
| 1394 | return atom_index; |
| 1370 | 1395 | } |
| 1371 | 1396 | |
| 1372 | | pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1397 | pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !Atom.Index { |
| 1373 | 1398 | const gpa = self.base.allocator; |
| 1374 | 1399 | const arch = self.base.options.target.cpu.arch; |
| 1375 | 1400 | const size: u4 = switch (arch) { |
| ... | ... | @@ -1377,9 +1402,8 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1377 | 1402 | .aarch64 => 3 * @sizeOf(u32), |
| 1378 | 1403 | else => unreachable, // unhandled architecture type |
| 1379 | 1404 | }; |
| 1380 | | const atom = try gpa.create(Atom); |
| 1381 | | atom.* = Atom.empty; |
| 1382 | | try atom.ensureInitialized(self); |
| 1405 | const atom_index = try self.createAtom(); |
| 1406 | const atom = self.getAtomPtr(atom_index); |
| 1383 | 1407 | atom.size = size; |
| 1384 | 1408 | atom.alignment = switch (arch) { |
| 1385 | 1409 | .x86_64 => 1, |
| ... | ... | @@ -1387,7 +1411,6 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1387 | 1411 | else => unreachable, // unhandled architecture type |
| 1388 | 1412 | |
| 1389 | 1413 | }; |
| 1390 | | errdefer gpa.destroy(atom); |
| 1391 | 1414 | |
| 1392 | 1415 | const sym = atom.getSymbolPtr(self); |
| 1393 | 1416 | sym.n_type = macho.N_SECT; |
| ... | ... | @@ -1403,7 +1426,7 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1403 | 1426 | code[0] = 0xff; |
| 1404 | 1427 | code[1] = 0x25; |
| 1405 | 1428 | |
| 1406 | | try atom.addRelocation(self, .{ |
| 1429 | try Atom.addRelocation(self, atom_index, .{ |
| 1407 | 1430 | .type = @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_BRANCH), |
| 1408 | 1431 | .target = .{ .sym_index = laptr_sym_index, .file = null }, |
| 1409 | 1432 | .offset = 2, |
| ... | ... | @@ -1424,7 +1447,7 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1424 | 1447 | // br x16 |
| 1425 | 1448 | mem.writeIntLittle(u32, code[8..12], aarch64.Instruction.br(.x16).toU32()); |
| 1426 | 1449 | |
| 1427 | | try atom.addRelocations(self, 2, .{ |
| 1450 | try Atom.addRelocations(self, atom_index, 2, .{ |
| 1428 | 1451 | .{ |
| 1429 | 1452 | .type = @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_PAGE21), |
| 1430 | 1453 | .target = .{ .sym_index = laptr_sym_index, .file = null }, |
| ... | ... | @@ -1446,13 +1469,11 @@ pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom { |
| 1446 | 1469 | else => unreachable, |
| 1447 | 1470 | } |
| 1448 | 1471 | |
| 1449 | | try self.managed_atoms.append(gpa, atom); |
| 1450 | | |
| 1451 | | sym.n_value = try self.allocateAtom(atom, size, atom.alignment); |
| 1472 | sym.n_value = try self.allocateAtom(atom_index, size, atom.alignment); |
| 1452 | 1473 | log.debug("allocated stub atom at 0x{x}", .{sym.n_value}); |
| 1453 | | try self.writeAtom(atom, code); |
| 1474 | try self.writeAtom(atom_index, code); |
| 1454 | 1475 | |
| 1455 | | return atom; |
| 1476 | return atom_index; |
| 1456 | 1477 | } |
| 1457 | 1478 | |
| 1458 | 1479 | pub fn createMhExecuteHeaderSymbol(self: *MachO) !void { |
| ... | ... | @@ -1586,9 +1607,12 @@ pub fn resolveSymbolsInDylibs(self: *MachO) !void { |
| 1586 | 1607 | if (self.stubs_table.contains(global)) break :blk; |
| 1587 | 1608 | |
| 1588 | 1609 | const stub_index = try self.allocateStubEntry(global); |
| 1589 | | const stub_helper_atom = try self.createStubHelperAtom(); |
| 1590 | | const laptr_atom = try self.createLazyPointerAtom(stub_helper_atom.getSymbolIndex().?, global); |
| 1591 | | const stub_atom = try self.createStubAtom(laptr_atom.getSymbolIndex().?); |
| 1610 | const stub_helper_atom_index = try self.createStubHelperAtom(); |
| 1611 | const stub_helper_atom = self.getAtom(stub_helper_atom_index); |
| 1612 | const laptr_atom_index = try self.createLazyPointerAtom(stub_helper_atom.getSymbolIndex().?, global); |
| 1613 | const laptr_atom = self.getAtom(laptr_atom_index); |
| 1614 | const stub_atom_index = try self.createStubAtom(laptr_atom.getSymbolIndex().?); |
| 1615 | const stub_atom = self.getAtom(stub_atom_index); |
| 1592 | 1616 | self.stubs.items[stub_index].sym_index = stub_atom.getSymbolIndex().?; |
| 1593 | 1617 | self.markRelocsDirtyByTarget(global); |
| 1594 | 1618 | } |
| ... | ... | @@ -1686,10 +1710,11 @@ pub fn resolveDyldStubBinder(self: *MachO) !void { |
| 1686 | 1710 | |
| 1687 | 1711 | // Add dyld_stub_binder as the final GOT entry. |
| 1688 | 1712 | const got_index = try self.allocateGotEntry(global); |
| 1689 | | const got_atom = try self.createGotAtom(global); |
| 1713 | const got_atom_index = try self.createGotAtom(global); |
| 1714 | const got_atom = self.getAtom(got_atom_index); |
| 1690 | 1715 | self.got_entries.items[got_index].sym_index = got_atom.getSymbolIndex().?; |
| 1691 | 1716 | |
| 1692 | | try self.writePtrWidthAtom(got_atom); |
| 1717 | try self.writePtrWidthAtom(got_atom_index); |
| 1693 | 1718 | } |
| 1694 | 1719 | |
| 1695 | 1720 | pub fn deinit(self: *MachO) void { |
| ... | ... | @@ -1699,9 +1724,9 @@ pub fn deinit(self: *MachO) void { |
| 1699 | 1724 | if (self.llvm_object) |llvm_object| llvm_object.destroy(gpa); |
| 1700 | 1725 | } |
| 1701 | 1726 | |
| 1702 | | if (self.d_sym) |*d_sym| { |
| 1703 | | d_sym.deinit(); |
| 1704 | | } |
| 1727 | // if (self.d_sym) |*d_sym| { |
| 1728 | // d_sym.deinit(); |
| 1729 | // } |
| 1705 | 1730 | |
| 1706 | 1731 | self.got_entries.deinit(gpa); |
| 1707 | 1732 | self.got_entries_free_list.deinit(gpa); |
| ... | ... | @@ -1739,12 +1764,12 @@ pub fn deinit(self: *MachO) void { |
| 1739 | 1764 | } |
| 1740 | 1765 | self.sections.deinit(gpa); |
| 1741 | 1766 | |
| 1742 | | for (self.managed_atoms.items) |atom| { |
| 1743 | | gpa.destroy(atom); |
| 1744 | | } |
| 1745 | | self.managed_atoms.deinit(gpa); |
| 1767 | self.atoms.deinit(gpa); |
| 1746 | 1768 | |
| 1747 | 1769 | if (self.base.options.module) |_| { |
| 1770 | for (self.decls.values()) |*m| { |
| 1771 | m.exports.deinit(gpa); |
| 1772 | } |
| 1748 | 1773 | self.decls.deinit(gpa); |
| 1749 | 1774 | } else { |
| 1750 | 1775 | assert(self.decls.count() == 0); |
| ... | ... | @@ -1778,14 +1803,15 @@ pub fn deinit(self: *MachO) void { |
| 1778 | 1803 | self.lazy_bindings.deinit(gpa); |
| 1779 | 1804 | } |
| 1780 | 1805 | |
| 1781 | | fn freeAtom(self: *MachO, atom: *Atom) void { |
| 1782 | | log.debug("freeAtom {*}", .{atom}); |
| 1806 | fn freeAtom(self: *MachO, atom_index: Atom.Index) void { |
| 1807 | log.debug("freeAtom {d}", .{atom_index}); |
| 1783 | 1808 | |
| 1784 | 1809 | const gpa = self.base.allocator; |
| 1785 | 1810 | |
| 1786 | 1811 | // Remove any relocs and base relocs associated with this Atom |
| 1787 | | self.freeRelocationsForAtom(atom); |
| 1812 | Atom.freeRelocations(self, atom_index); |
| 1788 | 1813 | |
| 1814 | const atom = self.getAtom(atom_index); |
| 1789 | 1815 | const sect_id = atom.getSymbol(self).n_sect - 1; |
| 1790 | 1816 | const free_list = &self.sections.items(.free_list)[sect_id]; |
| 1791 | 1817 | var already_have_free_list_node = false; |
| ... | ... | @@ -1793,45 +1819,46 @@ fn freeAtom(self: *MachO, atom: *Atom) void { |
| 1793 | 1819 | var i: usize = 0; |
| 1794 | 1820 | // TODO turn free_list into a hash map |
| 1795 | 1821 | while (i < free_list.items.len) { |
| 1796 | | if (free_list.items[i] == atom) { |
| 1822 | if (free_list.items[i] == atom_index) { |
| 1797 | 1823 | _ = free_list.swapRemove(i); |
| 1798 | 1824 | continue; |
| 1799 | 1825 | } |
| 1800 | | if (free_list.items[i] == atom.prev) { |
| 1826 | if (free_list.items[i] == atom.prev_index) { |
| 1801 | 1827 | already_have_free_list_node = true; |
| 1802 | 1828 | } |
| 1803 | 1829 | i += 1; |
| 1804 | 1830 | } |
| 1805 | 1831 | } |
| 1806 | 1832 | |
| 1807 | | const maybe_last_atom = &self.sections.items(.last_atom)[sect_id]; |
| 1808 | | if (maybe_last_atom.*) |last_atom| { |
| 1809 | | if (last_atom == atom) { |
| 1810 | | if (atom.prev) |prev| { |
| 1833 | const maybe_last_atom_index = &self.sections.items(.last_atom_index)[sect_id]; |
| 1834 | if (maybe_last_atom_index.*) |last_atom_index| { |
| 1835 | if (last_atom_index == atom_index) { |
| 1836 | if (atom.prev_index) |prev_index| { |
| 1811 | 1837 | // TODO shrink the section size here |
| 1812 | | maybe_last_atom.* = prev; |
| 1838 | maybe_last_atom_index.* = prev_index; |
| 1813 | 1839 | } else { |
| 1814 | | maybe_last_atom.* = null; |
| 1840 | maybe_last_atom_index.* = null; |
| 1815 | 1841 | } |
| 1816 | 1842 | } |
| 1817 | 1843 | } |
| 1818 | 1844 | |
| 1819 | | if (atom.prev) |prev| { |
| 1820 | | prev.next = atom.next; |
| 1845 | if (atom.prev_index) |prev_index| { |
| 1846 | const prev = self.getAtomPtr(prev_index); |
| 1847 | prev.next_index = atom.next_index; |
| 1821 | 1848 | |
| 1822 | | if (!already_have_free_list_node and prev.freeListEligible(self)) { |
| 1849 | if (!already_have_free_list_node and prev.*.freeListEligible(self)) { |
| 1823 | 1850 | // The free list is heuristics, it doesn't have to be perfect, so we can ignore |
| 1824 | 1851 | // the OOM here. |
| 1825 | | free_list.append(gpa, prev) catch {}; |
| 1852 | free_list.append(gpa, prev_index) catch {}; |
| 1826 | 1853 | } |
| 1827 | 1854 | } else { |
| 1828 | | atom.prev = null; |
| 1855 | self.getAtomPtr(atom_index).prev_index = null; |
| 1829 | 1856 | } |
| 1830 | 1857 | |
| 1831 | | if (atom.next) |next| { |
| 1832 | | next.prev = atom.prev; |
| 1858 | if (atom.next_index) |next_index| { |
| 1859 | self.getAtomPtr(next_index).prev_index = atom.prev_index; |
| 1833 | 1860 | } else { |
| 1834 | | atom.next = null; |
| 1861 | self.getAtomPtr(atom_index).next_index = null; |
| 1835 | 1862 | } |
| 1836 | 1863 | |
| 1837 | 1864 | // Appending to free lists is allowed to fail because the free lists are heuristics based anyway. |
| ... | ... | @@ -1849,9 +1876,9 @@ fn freeAtom(self: *MachO, atom: *Atom) void { |
| 1849 | 1876 | }; |
| 1850 | 1877 | _ = self.got_entries_table.remove(got_target); |
| 1851 | 1878 | |
| 1852 | | if (self.d_sym) |*d_sym| { |
| 1853 | | d_sym.swapRemoveRelocs(sym_index); |
| 1854 | | } |
| 1879 | // if (self.d_sym) |*d_sym| { |
| 1880 | // d_sym.swapRemoveRelocs(sym_index); |
| 1881 | // } |
| 1855 | 1882 | |
| 1856 | 1883 | log.debug(" adding GOT index {d} to free list (target local@{d})", .{ got_index, sym_index }); |
| 1857 | 1884 | } |
| ... | ... | @@ -1859,27 +1886,28 @@ fn freeAtom(self: *MachO, atom: *Atom) void { |
| 1859 | 1886 | self.locals.items[sym_index].n_type = 0; |
| 1860 | 1887 | _ = self.atom_by_index_table.remove(sym_index); |
| 1861 | 1888 | log.debug(" adding local symbol index {d} to free list", .{sym_index}); |
| 1862 | | atom.sym_index = 0; |
| 1889 | self.getAtomPtr(atom_index).sym_index = 0; |
| 1863 | 1890 | |
| 1864 | | if (self.d_sym) |*d_sym| { |
| 1865 | | d_sym.dwarf.freeAtom(&atom.dbg_info_atom); |
| 1866 | | } |
| 1891 | // if (self.d_sym) |*d_sym| { |
| 1892 | // d_sym.dwarf.freeAtom(&atom.dbg_info_atom); |
| 1893 | // } |
| 1867 | 1894 | } |
| 1868 | 1895 | |
| 1869 | | fn shrinkAtom(self: *MachO, atom: *Atom, new_block_size: u64) void { |
| 1896 | fn shrinkAtom(self: *MachO, atom_index: Atom.Index, new_block_size: u64) void { |
| 1870 | 1897 | _ = self; |
| 1871 | | _ = atom; |
| 1898 | _ = atom_index; |
| 1872 | 1899 | _ = new_block_size; |
| 1873 | 1900 | // TODO check the new capacity, and if it crosses the size threshold into a big enough |
| 1874 | 1901 | // capacity, insert a free list node for it. |
| 1875 | 1902 | } |
| 1876 | 1903 | |
| 1877 | | fn growAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) !u64 { |
| 1904 | fn growAtom(self: *MachO, atom_index: Atom.Index, new_atom_size: u64, alignment: u64) !u64 { |
| 1905 | const atom = self.getAtom(atom_index); |
| 1878 | 1906 | const sym = atom.getSymbol(self); |
| 1879 | 1907 | const align_ok = mem.alignBackwardGeneric(u64, sym.n_value, alignment) == sym.n_value; |
| 1880 | 1908 | const need_realloc = !align_ok or new_atom_size > atom.capacity(self); |
| 1881 | 1909 | if (!need_realloc) return sym.n_value; |
| 1882 | | return self.allocateAtom(atom, new_atom_size, alignment); |
| 1910 | return self.allocateAtom(atom_index, new_atom_size, alignment); |
| 1883 | 1911 | } |
| 1884 | 1912 | |
| 1885 | 1913 | pub fn allocateSymbol(self: *MachO) !u32 { |
| ... | ... | @@ -1986,31 +2014,29 @@ pub fn updateFunc(self: *MachO, module: *Module, func: *Module.Fn, air: Air, liv |
| 1986 | 2014 | |
| 1987 | 2015 | const decl_index = func.owner_decl; |
| 1988 | 2016 | const decl = module.declPtr(decl_index); |
| 1989 | | const atom = &decl.link.macho; |
| 1990 | | try atom.ensureInitialized(self); |
| 1991 | | const gop = try self.decls.getOrPut(self.base.allocator, decl_index); |
| 1992 | | if (gop.found_existing) { |
| 1993 | | self.freeUnnamedConsts(decl_index); |
| 1994 | | self.freeRelocationsForAtom(atom); |
| 1995 | | } else { |
| 1996 | | gop.value_ptr.* = null; |
| 1997 | | } |
| 2017 | |
| 2018 | const atom_index = try self.getOrCreateAtomForDecl(decl_index); |
| 2019 | self.freeUnnamedConsts(decl_index); |
| 2020 | Atom.freeRelocations(self, atom_index); |
| 2021 | |
| 2022 | const atom = self.getAtom(atom_index); |
| 2023 | _ = atom; |
| 1998 | 2024 | |
| 1999 | 2025 | var code_buffer = std.ArrayList(u8).init(self.base.allocator); |
| 2000 | 2026 | defer code_buffer.deinit(); |
| 2001 | 2027 | |
| 2002 | | var decl_state = if (self.d_sym) |*d_sym| |
| 2003 | | try d_sym.dwarf.initDeclState(module, decl_index) |
| 2004 | | else |
| 2005 | | null; |
| 2006 | | defer if (decl_state) |*ds| ds.deinit(); |
| 2028 | // var decl_state = if (self.d_sym) |*d_sym| |
| 2029 | // try d_sym.dwarf.initDeclState(module, decl_index) |
| 2030 | // else |
| 2031 | // null; |
| 2032 | // defer if (decl_state) |*ds| ds.deinit(); |
| 2007 | 2033 | |
| 2008 | | const res = if (decl_state) |*ds| |
| 2009 | | try codegen.generateFunction(&self.base, decl.srcLoc(), func, air, liveness, &code_buffer, .{ |
| 2010 | | .dwarf = ds, |
| 2011 | | }) |
| 2012 | | else |
| 2013 | | try codegen.generateFunction(&self.base, decl.srcLoc(), func, air, liveness, &code_buffer, .none); |
| 2034 | // const res = if (decl_state) |*ds| |
| 2035 | // try codegen.generateFunction(&self.base, decl.srcLoc(), func, air, liveness, &code_buffer, .{ |
| 2036 | // .dwarf = ds, |
| 2037 | // }) |
| 2038 | // else |
| 2039 | const res = try codegen.generateFunction(&self.base, decl.srcLoc(), func, air, liveness, &code_buffer, .none); |
| 2014 | 2040 | |
| 2015 | 2041 | const code = switch (res) { |
| 2016 | 2042 | .ok => code_buffer.items, |
| ... | ... | @@ -2022,16 +2048,11 @@ pub fn updateFunc(self: *MachO, module: *Module, func: *Module.Fn, air: Air, liv |
| 2022 | 2048 | }; |
| 2023 | 2049 | |
| 2024 | 2050 | const addr = try self.updateDeclCode(decl_index, code); |
| 2051 | _ = addr; |
| 2025 | 2052 | |
| 2026 | | if (decl_state) |*ds| { |
| 2027 | | try self.d_sym.?.dwarf.commitDeclState( |
| 2028 | | module, |
| 2029 | | decl_index, |
| 2030 | | addr, |
| 2031 | | decl.link.macho.size, |
| 2032 | | ds, |
| 2033 | | ); |
| 2034 | | } |
| 2053 | // if (decl_state) |*ds| { |
| 2054 | // try self.d_sym.?.dwarf.commitDeclState(module, decl_index, addr, atom.size, ds); |
| 2055 | // } |
| 2035 | 2056 | |
| 2036 | 2057 | // Since we updated the vaddr and the size, each corresponding export symbol also |
| 2037 | 2058 | // needs to be updated. |
| ... | ... | @@ -2065,11 +2086,8 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu |
| 2065 | 2086 | |
| 2066 | 2087 | log.debug("allocating symbol indexes for {?s}", .{name}); |
| 2067 | 2088 | |
| 2068 | | const atom = try gpa.create(Atom); |
| 2069 | | errdefer gpa.destroy(atom); |
| 2070 | | atom.* = Atom.empty; |
| 2071 | | try atom.ensureInitialized(self); |
| 2072 | | try self.managed_atoms.append(gpa, atom); |
| 2089 | const atom_index = try self.createAtom(); |
| 2090 | const atom = self.getAtomPtr(atom_index); |
| 2073 | 2091 | |
| 2074 | 2092 | const res = try codegen.generateSymbol(&self.base, decl.srcLoc(), typed_value, &code_buffer, .none, .{ |
| 2075 | 2093 | .parent_atom_index = atom.getSymbolIndex().?, |
| ... | ... | @@ -2088,21 +2106,21 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu |
| 2088 | 2106 | atom.size = code.len; |
| 2089 | 2107 | atom.alignment = required_alignment; |
| 2090 | 2108 | // TODO: work out logic for disambiguating functions from function pointers |
| 2091 | | // const sect_id = self.getDeclOutputSection(decl); |
| 2109 | // const sect_id = self.getDeclOutputSection(decl_index); |
| 2092 | 2110 | const sect_id = self.data_const_section_index.?; |
| 2093 | 2111 | const symbol = atom.getSymbolPtr(self); |
| 2094 | 2112 | symbol.n_strx = name_str_index; |
| 2095 | 2113 | symbol.n_type = macho.N_SECT; |
| 2096 | 2114 | symbol.n_sect = sect_id + 1; |
| 2097 | | symbol.n_value = try self.allocateAtom(atom, code.len, required_alignment); |
| 2098 | | errdefer self.freeAtom(atom); |
| 2115 | symbol.n_value = try self.allocateAtom(atom_index, code.len, required_alignment); |
| 2116 | errdefer self.freeAtom(atom_index); |
| 2099 | 2117 | |
| 2100 | | try unnamed_consts.append(gpa, atom); |
| 2118 | try unnamed_consts.append(gpa, atom_index); |
| 2101 | 2119 | |
| 2102 | 2120 | log.debug("allocated atom for {?s} at 0x{x}", .{ name, symbol.n_value }); |
| 2103 | 2121 | log.debug(" (required alignment 0x{x})", .{required_alignment}); |
| 2104 | 2122 | |
| 2105 | | try self.writeAtom(atom, code); |
| 2123 | try self.writeAtom(atom_index, code); |
| 2106 | 2124 | |
| 2107 | 2125 | return atom.getSymbolIndex().?; |
| 2108 | 2126 | } |
| ... | ... | @@ -2129,41 +2147,36 @@ pub fn updateDecl(self: *MachO, module: *Module, decl_index: Module.Decl.Index) |
| 2129 | 2147 | } |
| 2130 | 2148 | } |
| 2131 | 2149 | |
| 2132 | | const atom = &decl.link.macho; |
| 2133 | | try atom.ensureInitialized(self); |
| 2134 | | const gop = try self.decls.getOrPut(self.base.allocator, decl_index); |
| 2135 | | if (gop.found_existing) { |
| 2136 | | self.freeRelocationsForAtom(atom); |
| 2137 | | } else { |
| 2138 | | gop.value_ptr.* = null; |
| 2139 | | } |
| 2150 | const atom_index = try self.getOrCreateAtomForDecl(decl_index); |
| 2151 | Atom.freeRelocations(self, atom_index); |
| 2152 | const atom = self.getAtom(atom_index); |
| 2140 | 2153 | |
| 2141 | 2154 | var code_buffer = std.ArrayList(u8).init(self.base.allocator); |
| 2142 | 2155 | defer code_buffer.deinit(); |
| 2143 | 2156 | |
| 2144 | | var decl_state: ?Dwarf.DeclState = if (self.d_sym) |*d_sym| |
| 2145 | | try d_sym.dwarf.initDeclState(module, decl_index) |
| 2146 | | else |
| 2147 | | null; |
| 2148 | | defer if (decl_state) |*ds| ds.deinit(); |
| 2157 | // var decl_state: ?Dwarf.DeclState = if (self.d_sym) |*d_sym| |
| 2158 | // try d_sym.dwarf.initDeclState(module, decl_index) |
| 2159 | // else |
| 2160 | // null; |
| 2161 | // defer if (decl_state) |*ds| ds.deinit(); |
| 2149 | 2162 | |
| 2150 | 2163 | const decl_val = if (decl.val.castTag(.variable)) |payload| payload.data.init else decl.val; |
| 2151 | | const res = if (decl_state) |*ds| |
| 2152 | | try codegen.generateSymbol(&self.base, decl.srcLoc(), .{ |
| 2153 | | .ty = decl.ty, |
| 2154 | | .val = decl_val, |
| 2155 | | }, &code_buffer, .{ |
| 2156 | | .dwarf = ds, |
| 2157 | | }, .{ |
| 2158 | | .parent_atom_index = decl.link.macho.getSymbolIndex().?, |
| 2159 | | }) |
| 2160 | | else |
| 2161 | | try codegen.generateSymbol(&self.base, decl.srcLoc(), .{ |
| 2162 | | .ty = decl.ty, |
| 2163 | | .val = decl_val, |
| 2164 | | }, &code_buffer, .none, .{ |
| 2165 | | .parent_atom_index = decl.link.macho.getSymbolIndex().?, |
| 2166 | | }); |
| 2164 | // const res = if (decl_state) |*ds| |
| 2165 | // try codegen.generateSymbol(&self.base, decl.srcLoc(), .{ |
| 2166 | // .ty = decl.ty, |
| 2167 | // .val = decl_val, |
| 2168 | // }, &code_buffer, .{ |
| 2169 | // .dwarf = ds, |
| 2170 | // }, .{ |
| 2171 | // .parent_atom_index = atom.getSymbolIndex().?, |
| 2172 | // }) |
| 2173 | // else |
| 2174 | const res = try codegen.generateSymbol(&self.base, decl.srcLoc(), .{ |
| 2175 | .ty = decl.ty, |
| 2176 | .val = decl_val, |
| 2177 | }, &code_buffer, .none, .{ |
| 2178 | .parent_atom_index = atom.getSymbolIndex().?, |
| 2179 | }); |
| 2167 | 2180 | |
| 2168 | 2181 | const code = switch (res) { |
| 2169 | 2182 | .ok => code_buffer.items, |
| ... | ... | @@ -2174,23 +2187,31 @@ pub fn updateDecl(self: *MachO, module: *Module, decl_index: Module.Decl.Index) |
| 2174 | 2187 | }, |
| 2175 | 2188 | }; |
| 2176 | 2189 | const addr = try self.updateDeclCode(decl_index, code); |
| 2190 | _ = addr; |
| 2177 | 2191 | |
| 2178 | | if (decl_state) |*ds| { |
| 2179 | | try self.d_sym.?.dwarf.commitDeclState( |
| 2180 | | module, |
| 2181 | | decl_index, |
| 2182 | | addr, |
| 2183 | | decl.link.macho.size, |
| 2184 | | ds, |
| 2185 | | ); |
| 2186 | | } |
| 2192 | // if (decl_state) |*ds| { |
| 2193 | // try self.d_sym.?.dwarf.commitDeclState(module, decl_index, addr, atom.size, ds); |
| 2194 | // } |
| 2187 | 2195 | |
| 2188 | 2196 | // Since we updated the vaddr and the size, each corresponding export symbol also |
| 2189 | 2197 | // needs to be updated. |
| 2190 | 2198 | try self.updateDeclExports(module, decl_index, module.getDeclExports(decl_index)); |
| 2191 | 2199 | } |
| 2192 | 2200 | |
| 2193 | | fn getDeclOutputSection(self: *MachO, decl: *Module.Decl) u8 { |
| 2201 | pub fn getOrCreateAtomForDecl(self: *MachO, decl_index: Module.Decl.Index) !Atom.Index { |
| 2202 | const gop = try self.decls.getOrPut(self.base.allocator, decl_index); |
| 2203 | if (!gop.found_existing) { |
| 2204 | gop.value_ptr.* = .{ |
| 2205 | .atom = try self.createAtom(), |
| 2206 | .section = self.getDeclOutputSection(decl_index), |
| 2207 | .exports = .{}, |
| 2208 | }; |
| 2209 | } |
| 2210 | return gop.value_ptr.atom; |
| 2211 | } |
| 2212 | |
| 2213 | fn getDeclOutputSection(self: *MachO, decl_index: Module.Decl.Index) u8 { |
| 2214 | const decl = self.base.options.module.?.declPtr(decl_index); |
| 2194 | 2215 | const ty = decl.ty; |
| 2195 | 2216 | const val = decl.val; |
| 2196 | 2217 | const zig_ty = ty.zigTypeTag(); |
| ... | ... | @@ -2341,13 +2362,11 @@ fn updateDeclCode(self: *MachO, decl_index: Module.Decl.Index, code: []const u8) |
| 2341 | 2362 | const sym_name = try decl.getFullyQualifiedName(mod); |
| 2342 | 2363 | defer self.base.allocator.free(sym_name); |
| 2343 | 2364 | |
| 2344 | | const atom = &decl.link.macho; |
| 2345 | | const sym_index = atom.getSymbolIndex().?; // Atom was not initialized |
| 2346 | | const decl_ptr = self.decls.getPtr(decl_index).?; |
| 2347 | | if (decl_ptr.* == null) { |
| 2348 | | decl_ptr.* = self.getDeclOutputSection(decl); |
| 2349 | | } |
| 2350 | | const sect_id = decl_ptr.*.?; |
| 2365 | const decl_metadata = self.decls.get(decl_index).?; |
| 2366 | const atom_index = decl_metadata.atom; |
| 2367 | const atom = self.getAtom(atom_index); |
| 2368 | const sym_index = atom.getSymbolIndex().?; |
| 2369 | const sect_id = decl_metadata.section; |
| 2351 | 2370 | const code_len = code.len; |
| 2352 | 2371 | |
| 2353 | 2372 | if (atom.size != 0) { |
| ... | ... | @@ -2357,11 +2376,11 @@ fn updateDeclCode(self: *MachO, decl_index: Module.Decl.Index, code: []const u8) |
| 2357 | 2376 | sym.n_sect = sect_id + 1; |
| 2358 | 2377 | sym.n_desc = 0; |
| 2359 | 2378 | |
| 2360 | | const capacity = decl.link.macho.capacity(self); |
| 2379 | const capacity = atom.capacity(self); |
| 2361 | 2380 | const need_realloc = code_len > capacity or !mem.isAlignedGeneric(u64, sym.n_value, required_alignment); |
| 2362 | 2381 | |
| 2363 | 2382 | if (need_realloc) { |
| 2364 | | const vaddr = try self.growAtom(atom, code_len, required_alignment); |
| 2383 | const vaddr = try self.growAtom(atom_index, code_len, required_alignment); |
| 2365 | 2384 | log.debug("growing {s} and moving from 0x{x} to 0x{x}", .{ sym_name, sym.n_value, vaddr }); |
| 2366 | 2385 | log.debug(" (required alignment 0x{x})", .{required_alignment}); |
| 2367 | 2386 | |
| ... | ... | @@ -2369,19 +2388,19 @@ fn updateDeclCode(self: *MachO, decl_index: Module.Decl.Index, code: []const u8) |
| 2369 | 2388 | sym.n_value = vaddr; |
| 2370 | 2389 | log.debug(" (updating GOT entry)", .{}); |
| 2371 | 2390 | const got_target = SymbolWithLoc{ .sym_index = sym_index, .file = null }; |
| 2372 | | const got_atom = self.getGotAtomForSymbol(got_target).?; |
| 2391 | const got_atom_index = self.getGotAtomIndexForSymbol(got_target).?; |
| 2373 | 2392 | self.markRelocsDirtyByTarget(got_target); |
| 2374 | | try self.writePtrWidthAtom(got_atom); |
| 2393 | try self.writePtrWidthAtom(got_atom_index); |
| 2375 | 2394 | } |
| 2376 | 2395 | } else if (code_len < atom.size) { |
| 2377 | | self.shrinkAtom(atom, code_len); |
| 2378 | | } else if (atom.next == null) { |
| 2396 | self.shrinkAtom(atom_index, code_len); |
| 2397 | } else if (atom.next_index == null) { |
| 2379 | 2398 | const header = &self.sections.items(.header)[sect_id]; |
| 2380 | 2399 | const segment = self.getSegment(sect_id); |
| 2381 | 2400 | const needed_size = (sym.n_value + code_len) - segment.vmaddr; |
| 2382 | 2401 | header.size = needed_size; |
| 2383 | 2402 | } |
| 2384 | | atom.size = code_len; |
| 2403 | self.getAtomPtr(atom_index).size = code_len; |
| 2385 | 2404 | } else { |
| 2386 | 2405 | const name_str_index = try self.strtab.insert(gpa, sym_name); |
| 2387 | 2406 | const sym = atom.getSymbolPtr(self); |
| ... | ... | @@ -2390,33 +2409,36 @@ fn updateDeclCode(self: *MachO, decl_index: Module.Decl.Index, code: []const u8) |
| 2390 | 2409 | sym.n_sect = sect_id + 1; |
| 2391 | 2410 | sym.n_desc = 0; |
| 2392 | 2411 | |
| 2393 | | const vaddr = try self.allocateAtom(atom, code_len, required_alignment); |
| 2394 | | errdefer self.freeAtom(atom); |
| 2412 | const vaddr = try self.allocateAtom(atom_index, code_len, required_alignment); |
| 2413 | errdefer self.freeAtom(atom_index); |
| 2395 | 2414 | |
| 2396 | 2415 | log.debug("allocated atom for {s} at 0x{x}", .{ sym_name, vaddr }); |
| 2397 | 2416 | log.debug(" (required alignment 0x{x})", .{required_alignment}); |
| 2398 | 2417 | |
| 2399 | | atom.size = code_len; |
| 2418 | self.getAtomPtr(atom_index).size = code_len; |
| 2400 | 2419 | sym.n_value = vaddr; |
| 2401 | 2420 | |
| 2402 | 2421 | const got_target = SymbolWithLoc{ .sym_index = sym_index, .file = null }; |
| 2403 | 2422 | const got_index = try self.allocateGotEntry(got_target); |
| 2404 | | const got_atom = try self.createGotAtom(got_target); |
| 2423 | const got_atom_index = try self.createGotAtom(got_target); |
| 2424 | const got_atom = self.getAtom(got_atom_index); |
| 2405 | 2425 | self.got_entries.items[got_index].sym_index = got_atom.getSymbolIndex().?; |
| 2406 | | try self.writePtrWidthAtom(got_atom); |
| 2426 | try self.writePtrWidthAtom(got_atom_index); |
| 2407 | 2427 | } |
| 2408 | 2428 | |
| 2409 | 2429 | self.markRelocsDirtyByTarget(atom.getSymbolWithLoc()); |
| 2410 | | try self.writeAtom(atom, code); |
| 2430 | try self.writeAtom(atom_index, code); |
| 2411 | 2431 | |
| 2412 | 2432 | return atom.getSymbol(self).n_value; |
| 2413 | 2433 | } |
| 2414 | 2434 | |
| 2415 | 2435 | pub fn updateDeclLineNumber(self: *MachO, module: *Module, decl: *const Module.Decl) !void { |
| 2436 | _ = decl; |
| 2437 | _ = self; |
| 2416 | 2438 | _ = module; |
| 2417 | | if (self.d_sym) |*d_sym| { |
| 2418 | | try d_sym.dwarf.updateDeclLineNumber(decl); |
| 2419 | | } |
| 2439 | // if (self.d_sym) |*d_sym| { |
| 2440 | // try d_sym.dwarf.updateDeclLineNumber(decl); |
| 2441 | // } |
| 2420 | 2442 | } |
| 2421 | 2443 | |
| 2422 | 2444 | pub fn updateDeclExports( |
| ... | ... | @@ -2432,22 +2454,17 @@ pub fn updateDeclExports( |
| 2432 | 2454 | if (self.llvm_object) |llvm_object| |
| 2433 | 2455 | return llvm_object.updateDeclExports(module, decl_index, exports); |
| 2434 | 2456 | } |
| 2457 | |
| 2435 | 2458 | const tracy = trace(@src()); |
| 2436 | 2459 | defer tracy.end(); |
| 2437 | 2460 | |
| 2438 | 2461 | const gpa = self.base.allocator; |
| 2439 | 2462 | |
| 2440 | 2463 | const decl = module.declPtr(decl_index); |
| 2441 | | const atom = &decl.link.macho; |
| 2442 | | |
| 2443 | | if (atom.getSymbolIndex() == null) return; |
| 2444 | | |
| 2445 | | const gop = try self.decls.getOrPut(gpa, decl_index); |
| 2446 | | if (!gop.found_existing) { |
| 2447 | | gop.value_ptr.* = self.getDeclOutputSection(decl); |
| 2448 | | } |
| 2449 | | |
| 2464 | const atom_index = try self.getOrCreateAtomForDecl(decl_index); |
| 2465 | const atom = self.getAtom(atom_index); |
| 2450 | 2466 | const decl_sym = atom.getSymbol(self); |
| 2467 | const decl_metadata = self.decls.getPtr(decl_index).?; |
| 2451 | 2468 | |
| 2452 | 2469 | for (exports) |exp| { |
| 2453 | 2470 | const exp_name = try std.fmt.allocPrint(gpa, "_{s}", .{exp.options.name}); |
| ... | ... | @@ -2485,9 +2502,9 @@ pub fn updateDeclExports( |
| 2485 | 2502 | continue; |
| 2486 | 2503 | } |
| 2487 | 2504 | |
| 2488 | | const sym_index = exp.link.macho.sym_index orelse blk: { |
| 2505 | const sym_index = decl_metadata.getExport(self, exp_name) orelse blk: { |
| 2489 | 2506 | const sym_index = try self.allocateSymbol(); |
| 2490 | | exp.link.macho.sym_index = sym_index; |
| 2507 | try decl_metadata.exports.append(gpa, sym_index); |
| 2491 | 2508 | break :blk sym_index; |
| 2492 | 2509 | }; |
| 2493 | 2510 | const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = null }; |
| ... | ... | @@ -2535,16 +2552,18 @@ pub fn updateDeclExports( |
| 2535 | 2552 | } |
| 2536 | 2553 | } |
| 2537 | 2554 | |
| 2538 | | pub fn deleteExport(self: *MachO, exp: Export) void { |
| 2555 | pub fn deleteDeclExport(self: *MachO, decl_index: Module.Decl.Index, name: []const u8) Allocator.Error!void { |
| 2539 | 2556 | if (self.llvm_object) |_| return; |
| 2540 | | const sym_index = exp.sym_index orelse return; |
| 2557 | const metadata = self.decls.getPtr(decl_index) orelse return; |
| 2541 | 2558 | |
| 2542 | 2559 | const gpa = self.base.allocator; |
| 2560 | const exp_name = try std.fmt.allocPrint(gpa, "_{s}", .{name}); |
| 2561 | defer gpa.free(exp_name); |
| 2562 | const sym_index = metadata.getExportPtr(self, exp_name) orelse return; |
| 2543 | 2563 | |
| 2544 | | const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = null }; |
| 2564 | const sym_loc = SymbolWithLoc{ .sym_index = sym_index.*, .file = null }; |
| 2545 | 2565 | const sym = self.getSymbolPtr(sym_loc); |
| 2546 | | const sym_name = self.getSymbolName(sym_loc); |
| 2547 | | log.debug("deleting export '{s}'", .{sym_name}); |
| 2566 | log.debug("deleting export '{s}'", .{exp_name}); |
| 2548 | 2567 | assert(sym.sect() and sym.ext()); |
| 2549 | 2568 | sym.* = .{ |
| 2550 | 2569 | .n_strx = 0, |
| ... | ... | @@ -2553,9 +2572,9 @@ pub fn deleteExport(self: *MachO, exp: Export) void { |
| 2553 | 2572 | .n_desc = 0, |
| 2554 | 2573 | .n_value = 0, |
| 2555 | 2574 | }; |
| 2556 | | self.locals_free_list.append(gpa, sym_index) catch {}; |
| 2575 | self.locals_free_list.append(gpa, sym_index.*) catch {}; |
| 2557 | 2576 | |
| 2558 | | if (self.resolver.fetchRemove(sym_name)) |entry| { |
| 2577 | if (self.resolver.fetchRemove(exp_name)) |entry| { |
| 2559 | 2578 | defer gpa.free(entry.key); |
| 2560 | 2579 | self.globals_free_list.append(gpa, entry.value) catch {}; |
| 2561 | 2580 | self.globals.items[entry.value] = .{ |
| ... | ... | @@ -2563,17 +2582,8 @@ pub fn deleteExport(self: *MachO, exp: Export) void { |
| 2563 | 2582 | .file = null, |
| 2564 | 2583 | }; |
| 2565 | 2584 | } |
| 2566 | | } |
| 2567 | 2585 | |
| 2568 | | fn freeRelocationsForAtom(self: *MachO, atom: *Atom) void { |
| 2569 | | var removed_relocs = self.relocs.fetchOrderedRemove(atom); |
| 2570 | | if (removed_relocs) |*relocs| relocs.value.deinit(self.base.allocator); |
| 2571 | | var removed_rebases = self.rebases.fetchOrderedRemove(atom); |
| 2572 | | if (removed_rebases) |*rebases| rebases.value.deinit(self.base.allocator); |
| 2573 | | var removed_bindings = self.bindings.fetchOrderedRemove(atom); |
| 2574 | | if (removed_bindings) |*bindings| bindings.value.deinit(self.base.allocator); |
| 2575 | | var removed_lazy_bindings = self.lazy_bindings.fetchOrderedRemove(atom); |
| 2576 | | if (removed_lazy_bindings) |*lazy_bindings| lazy_bindings.value.deinit(self.base.allocator); |
| 2586 | sym_index.* = 0; |
| 2577 | 2587 | } |
| 2578 | 2588 | |
| 2579 | 2589 | fn freeUnnamedConsts(self: *MachO, decl_index: Module.Decl.Index) void { |
| ... | ... | @@ -2595,28 +2605,22 @@ pub fn freeDecl(self: *MachO, decl_index: Module.Decl.Index) void { |
| 2595 | 2605 | log.debug("freeDecl {*}", .{decl}); |
| 2596 | 2606 | |
| 2597 | 2607 | if (self.decls.fetchSwapRemove(decl_index)) |kv| { |
| 2598 | | if (kv.value) |_| { |
| 2599 | | self.freeAtom(&decl.link.macho); |
| 2600 | | self.freeUnnamedConsts(decl_index); |
| 2601 | | } |
| 2608 | self.freeAtom(kv.value.atom); |
| 2609 | self.freeUnnamedConsts(decl_index); |
| 2602 | 2610 | } |
| 2603 | 2611 | |
| 2604 | | if (self.d_sym) |*d_sym| { |
| 2605 | | d_sym.dwarf.freeDecl(decl); |
| 2606 | | } |
| 2612 | // if (self.d_sym) |*d_sym| { |
| 2613 | // d_sym.dwarf.freeDecl(decl); |
| 2614 | // } |
| 2607 | 2615 | } |
| 2608 | 2616 | |
| 2609 | 2617 | pub fn getDeclVAddr(self: *MachO, decl_index: Module.Decl.Index, reloc_info: File.RelocInfo) !u64 { |
| 2610 | | const mod = self.base.options.module.?; |
| 2611 | | const decl = mod.declPtr(decl_index); |
| 2612 | | |
| 2613 | 2618 | assert(self.llvm_object == null); |
| 2614 | 2619 | |
| 2615 | | try decl.link.macho.ensureInitialized(self); |
| 2616 | | const sym_index = decl.link.macho.getSymbolIndex().?; |
| 2617 | | |
| 2618 | | const atom = self.getAtomForSymbol(.{ .sym_index = reloc_info.parent_atom_index, .file = null }).?; |
| 2619 | | try atom.addRelocation(self, .{ |
| 2620 | const this_atom_index = try self.getOrCreateAtomForDecl(decl_index); |
| 2621 | const sym_index = self.getAtom(this_atom_index).getSymbolIndex().?; |
| 2622 | const atom_index = self.getAtomIndexForSymbol(.{ .sym_index = reloc_info.parent_atom_index, .file = null }).?; |
| 2623 | try Atom.addRelocation(self, atom_index, .{ |
| 2620 | 2624 | .type = switch (self.base.options.target.cpu.arch) { |
| 2621 | 2625 | .aarch64 => @enumToInt(macho.reloc_type_arm64.ARM64_RELOC_UNSIGNED), |
| 2622 | 2626 | .x86_64 => @enumToInt(macho.reloc_type_x86_64.X86_64_RELOC_UNSIGNED), |
| ... | ... | @@ -2628,7 +2632,7 @@ pub fn getDeclVAddr(self: *MachO, decl_index: Module.Decl.Index, reloc_info: Fil |
| 2628 | 2632 | .pcrel = false, |
| 2629 | 2633 | .length = 3, |
| 2630 | 2634 | }); |
| 2631 | | try atom.addRebase(self, @intCast(u32, reloc_info.offset)); |
| 2635 | try Atom.addRebase(self, atom_index, @intCast(u32, reloc_info.offset)); |
| 2632 | 2636 | |
| 2633 | 2637 | return 0; |
| 2634 | 2638 | } |
| ... | ... | @@ -2860,34 +2864,36 @@ fn moveSectionInVirtualMemory(self: *MachO, sect_id: u8, needed_size: u64) !void |
| 2860 | 2864 | // TODO: enforce order by increasing VM addresses in self.sections container. |
| 2861 | 2865 | for (self.sections.items(.header)[sect_id + 1 ..]) |*next_header, next_sect_id| { |
| 2862 | 2866 | const index = @intCast(u8, sect_id + 1 + next_sect_id); |
| 2863 | | const maybe_last_atom = &self.sections.items(.last_atom)[index]; |
| 2864 | 2867 | const next_segment = self.getSegmentPtr(index); |
| 2865 | 2868 | next_header.addr += diff; |
| 2866 | 2869 | next_segment.vmaddr += diff; |
| 2867 | 2870 | |
| 2868 | | if (maybe_last_atom.*) |last_atom| { |
| 2869 | | var atom = last_atom; |
| 2871 | const maybe_last_atom_index = &self.sections.items(.last_atom_index)[index]; |
| 2872 | if (maybe_last_atom_index.*) |last_atom_index| { |
| 2873 | var atom_index = last_atom_index; |
| 2870 | 2874 | while (true) { |
| 2875 | const atom = self.getAtom(atom_index); |
| 2871 | 2876 | const sym = atom.getSymbolPtr(self); |
| 2872 | 2877 | sym.n_value += diff; |
| 2873 | 2878 | |
| 2874 | | if (atom.prev) |prev| { |
| 2875 | | atom = prev; |
| 2879 | if (atom.prev_index) |prev_index| { |
| 2880 | atom_index = prev_index; |
| 2876 | 2881 | } else break; |
| 2877 | 2882 | } |
| 2878 | 2883 | } |
| 2879 | 2884 | } |
| 2880 | 2885 | } |
| 2881 | 2886 | |
| 2882 | | fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) !u64 { |
| 2887 | fn allocateAtom(self: *MachO, atom_index: Atom.Index, new_atom_size: u64, alignment: u64) !u64 { |
| 2883 | 2888 | const tracy = trace(@src()); |
| 2884 | 2889 | defer tracy.end(); |
| 2885 | 2890 | |
| 2891 | const atom = self.getAtom(atom_index); |
| 2886 | 2892 | const sect_id = atom.getSymbol(self).n_sect - 1; |
| 2887 | 2893 | const segment = self.getSegmentPtr(sect_id); |
| 2888 | 2894 | const header = &self.sections.items(.header)[sect_id]; |
| 2889 | 2895 | const free_list = &self.sections.items(.free_list)[sect_id]; |
| 2890 | | const maybe_last_atom = &self.sections.items(.last_atom)[sect_id]; |
| 2896 | const maybe_last_atom_index = &self.sections.items(.last_atom_index)[sect_id]; |
| 2891 | 2897 | const requires_padding = blk: { |
| 2892 | 2898 | if (!header.isCode()) break :blk false; |
| 2893 | 2899 | if (header.isSymbolStubs()) break :blk false; |
| ... | ... | @@ -2901,7 +2907,7 @@ fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) ! |
| 2901 | 2907 | // It would be simpler to do it inside the for loop below, but that would cause a |
| 2902 | 2908 | // problem if an error was returned later in the function. So this action |
| 2903 | 2909 | // is actually carried out at the end of the function, when errors are no longer possible. |
| 2904 | | var atom_placement: ?*Atom = null; |
| 2910 | var atom_placement: ?Atom.Index = null; |
| 2905 | 2911 | var free_list_removal: ?usize = null; |
| 2906 | 2912 | |
| 2907 | 2913 | // First we look for an appropriately sized free list node. |
| ... | ... | @@ -2909,7 +2915,8 @@ fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) ! |
| 2909 | 2915 | var vaddr = blk: { |
| 2910 | 2916 | var i: usize = 0; |
| 2911 | 2917 | while (i < free_list.items.len) { |
| 2912 | | const big_atom = free_list.items[i]; |
| 2918 | const big_atom_index = free_list.items[i]; |
| 2919 | const big_atom = self.getAtom(big_atom_index); |
| 2913 | 2920 | // We now have a pointer to a live atom that has too much capacity. |
| 2914 | 2921 | // Is it enough that we could fit this new atom? |
| 2915 | 2922 | const sym = big_atom.getSymbol(self); |
| ... | ... | @@ -2937,30 +2944,35 @@ fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) ! |
| 2937 | 2944 | const keep_free_list_node = remaining_capacity >= min_text_capacity; |
| 2938 | 2945 | |
| 2939 | 2946 | // Set up the metadata to be updated, after errors are no longer possible. |
| 2940 | | atom_placement = big_atom; |
| 2947 | atom_placement = big_atom_index; |
| 2941 | 2948 | if (!keep_free_list_node) { |
| 2942 | 2949 | free_list_removal = i; |
| 2943 | 2950 | } |
| 2944 | 2951 | break :blk new_start_vaddr; |
| 2945 | | } else if (maybe_last_atom.*) |last| { |
| 2952 | } else if (maybe_last_atom_index.*) |last_index| { |
| 2953 | const last = self.getAtom(last_index); |
| 2946 | 2954 | const last_symbol = last.getSymbol(self); |
| 2947 | 2955 | const ideal_capacity = if (requires_padding) padToIdeal(last.size) else last.size; |
| 2948 | 2956 | const ideal_capacity_end_vaddr = last_symbol.n_value + ideal_capacity; |
| 2949 | 2957 | const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, alignment); |
| 2950 | | atom_placement = last; |
| 2958 | atom_placement = last_index; |
| 2951 | 2959 | break :blk new_start_vaddr; |
| 2952 | 2960 | } else { |
| 2953 | 2961 | break :blk mem.alignForwardGeneric(u64, segment.vmaddr, alignment); |
| 2954 | 2962 | } |
| 2955 | 2963 | }; |
| 2956 | 2964 | |
| 2957 | | const expand_section = atom_placement == null or atom_placement.?.next == null; |
| 2965 | const expand_section = if (atom_placement) |placement_index| |
| 2966 | self.getAtom(placement_index).next_index == null |
| 2967 | else |
| 2968 | true; |
| 2958 | 2969 | if (expand_section) { |
| 2959 | 2970 | const sect_capacity = self.allocatedSize(header.offset); |
| 2960 | 2971 | const needed_size = (vaddr + new_atom_size) - segment.vmaddr; |
| 2961 | 2972 | if (needed_size > sect_capacity) { |
| 2962 | 2973 | const new_offset = self.findFreeSpace(needed_size, self.page_size); |
| 2963 | | const current_size = if (maybe_last_atom.*) |last_atom| blk: { |
| 2974 | const current_size = if (maybe_last_atom_index.*) |last_atom_index| blk: { |
| 2975 | const last_atom = self.getAtom(last_atom_index); |
| 2964 | 2976 | const sym = last_atom.getSymbol(self); |
| 2965 | 2977 | break :blk (sym.n_value + last_atom.size) - segment.vmaddr; |
| 2966 | 2978 | } else 0; |
| ... | ... | @@ -2992,7 +3004,7 @@ fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) ! |
| 2992 | 3004 | header.size = needed_size; |
| 2993 | 3005 | segment.filesize = mem.alignForwardGeneric(u64, needed_size, self.page_size); |
| 2994 | 3006 | segment.vmsize = mem.alignForwardGeneric(u64, needed_size, self.page_size); |
| 2995 | | maybe_last_atom.* = atom; |
| 3007 | maybe_last_atom_index.* = atom_index; |
| 2996 | 3008 | |
| 2997 | 3009 | self.segment_table_dirty = true; |
| 2998 | 3010 | } |
| ... | ... | @@ -3002,20 +3014,25 @@ fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64) ! |
| 3002 | 3014 | header.@"align" = align_pow; |
| 3003 | 3015 | } |
| 3004 | 3016 | |
| 3005 | | if (atom.prev) |prev| { |
| 3006 | | prev.next = atom.next; |
| 3017 | if (atom.prev_index) |prev_index| { |
| 3018 | const prev = self.getAtomPtr(prev_index); |
| 3019 | prev.next_index = atom.next_index; |
| 3007 | 3020 | } |
| 3008 | | if (atom.next) |next| { |
| 3009 | | next.prev = atom.prev; |
| 3021 | if (atom.next_index) |next_index| { |
| 3022 | const next = self.getAtomPtr(next_index); |
| 3023 | next.prev_index = atom.prev_index; |
| 3010 | 3024 | } |
| 3011 | 3025 | |
| 3012 | | if (atom_placement) |big_atom| { |
| 3013 | | atom.prev = big_atom; |
| 3014 | | atom.next = big_atom.next; |
| 3015 | | big_atom.next = atom; |
| 3026 | if (atom_placement) |big_atom_index| { |
| 3027 | const big_atom = self.getAtomPtr(big_atom_index); |
| 3028 | const atom_ptr = self.getAtomPtr(atom_index); |
| 3029 | atom_ptr.prev_index = big_atom_index; |
| 3030 | atom_ptr.next_index = big_atom.next_index; |
| 3031 | big_atom.next_index = atom_index; |
| 3016 | 3032 | } else { |
| 3017 | | atom.prev = null; |
| 3018 | | atom.next = null; |
| 3033 | const atom_ptr = self.getAtomPtr(atom_index); |
| 3034 | atom_ptr.prev_index = null; |
| 3035 | atom_ptr.next_index = null; |
| 3019 | 3036 | } |
| 3020 | 3037 | if (free_list_removal) |i| { |
| 3021 | 3038 | _ = free_list.swapRemove(i); |
| ... | ... | @@ -3155,7 +3172,8 @@ fn collectRebaseData(self: *MachO, rebase: *Rebase) !void { |
| 3155 | 3172 | const gpa = self.base.allocator; |
| 3156 | 3173 | const slice = self.sections.slice(); |
| 3157 | 3174 | |
| 3158 | | for (self.rebases.keys()) |atom, i| { |
| 3175 | for (self.rebases.keys()) |atom_index, i| { |
| 3176 | const atom = self.getAtom(atom_index); |
| 3159 | 3177 | log.debug(" ATOM(%{?d}, '{s}')", .{ atom.getSymbolIndex(), atom.getName(self) }); |
| 3160 | 3178 | |
| 3161 | 3179 | const sym = atom.getSymbol(self); |
| ... | ... | @@ -3184,7 +3202,8 @@ fn collectBindData(self: *MachO, bind: anytype, raw_bindings: anytype) !void { |
| 3184 | 3202 | const gpa = self.base.allocator; |
| 3185 | 3203 | const slice = self.sections.slice(); |
| 3186 | 3204 | |
| 3187 | | for (raw_bindings.keys()) |atom, i| { |
| 3205 | for (raw_bindings.keys()) |atom_index, i| { |
| 3206 | const atom = self.getAtom(atom_index); |
| 3188 | 3207 | log.debug(" ATOM(%{?d}, '{s}')", .{ atom.getSymbolIndex(), atom.getName(self) }); |
| 3189 | 3208 | |
| 3190 | 3209 | const sym = atom.getSymbol(self); |
| ... | ... | @@ -3359,7 +3378,7 @@ fn populateLazyBindOffsetsInStubHelper(self: *MachO, lazy_bind: LazyBind) !void |
| 3359 | 3378 | if (lazy_bind.size() == 0) return; |
| 3360 | 3379 | |
| 3361 | 3380 | const stub_helper_section_index = self.stub_helper_section_index.?; |
| 3362 | | assert(self.stub_helper_preamble_atom != null); |
| 3381 | assert(self.stub_helper_preamble_atom_index != null); |
| 3363 | 3382 | |
| 3364 | 3383 | const section = self.sections.get(stub_helper_section_index); |
| 3365 | 3384 | |
| ... | ... | @@ -3369,10 +3388,11 @@ fn populateLazyBindOffsetsInStubHelper(self: *MachO, lazy_bind: LazyBind) !void |
| 3369 | 3388 | else => unreachable, |
| 3370 | 3389 | }; |
| 3371 | 3390 | const header = section.header; |
| 3372 | | var atom = section.last_atom.?; |
| 3391 | var atom_index = section.last_atom_index.?; |
| 3373 | 3392 | |
| 3374 | 3393 | var index: usize = lazy_bind.offsets.items.len; |
| 3375 | 3394 | while (index > 0) : (index -= 1) { |
| 3395 | const atom = self.getAtom(atom_index); |
| 3376 | 3396 | const sym = atom.getSymbol(self); |
| 3377 | 3397 | const file_offset = header.offset + sym.n_value - header.addr + stub_offset; |
| 3378 | 3398 | const bind_offset = lazy_bind.offsets.items[index - 1]; |
| ... | ... | @@ -3385,7 +3405,7 @@ fn populateLazyBindOffsetsInStubHelper(self: *MachO, lazy_bind: LazyBind) !void |
| 3385 | 3405 | |
| 3386 | 3406 | try self.base.file.?.pwriteAll(mem.asBytes(&bind_offset), file_offset); |
| 3387 | 3407 | |
| 3388 | | atom = atom.prev.?; |
| 3408 | atom_index = atom.prev_index.?; |
| 3389 | 3409 | } |
| 3390 | 3410 | } |
| 3391 | 3411 | |
| ... | ... | @@ -3828,25 +3848,35 @@ pub fn getOrPutGlobalPtr(self: *MachO, name: []const u8) !GetOrPutGlobalPtrResul |
| 3828 | 3848 | return GetOrPutGlobalPtrResult{ .found_existing = false, .value_ptr = ptr }; |
| 3829 | 3849 | } |
| 3830 | 3850 | |
| 3851 | pub fn getAtom(self: *MachO, atom_index: Atom.Index) Atom { |
| 3852 | assert(atom_index < self.atoms.items.len); |
| 3853 | return self.atoms.items[atom_index]; |
| 3854 | } |
| 3855 | |
| 3856 | pub fn getAtomPtr(self: *MachO, atom_index: Atom.Index) *Atom { |
| 3857 | assert(atom_index < self.atoms.items.len); |
| 3858 | return &self.atoms.items[atom_index]; |
| 3859 | } |
| 3860 | |
| 3831 | 3861 | /// Returns atom if there is an atom referenced by the symbol described by `sym_with_loc` descriptor. |
| 3832 | 3862 | /// Returns null on failure. |
| 3833 | | pub fn getAtomForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?*Atom { |
| 3863 | pub fn getAtomIndexForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?Atom.Index { |
| 3834 | 3864 | assert(sym_with_loc.file == null); |
| 3835 | 3865 | return self.atom_by_index_table.get(sym_with_loc.sym_index); |
| 3836 | 3866 | } |
| 3837 | 3867 | |
| 3838 | 3868 | /// Returns GOT atom that references `sym_with_loc` if one exists. |
| 3839 | 3869 | /// Returns null otherwise. |
| 3840 | | pub fn getGotAtomForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?*Atom { |
| 3870 | pub fn getGotAtomIndexForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?Atom.Index { |
| 3841 | 3871 | const got_index = self.got_entries_table.get(sym_with_loc) orelse return null; |
| 3842 | | return self.got_entries.items[got_index].getAtom(self); |
| 3872 | return self.got_entries.items[got_index].getAtomIndex(self); |
| 3843 | 3873 | } |
| 3844 | 3874 | |
| 3845 | 3875 | /// Returns stubs atom that references `sym_with_loc` if one exists. |
| 3846 | 3876 | /// Returns null otherwise. |
| 3847 | | pub fn getStubsAtomForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?*Atom { |
| 3877 | pub fn getStubsAtomIndexForSymbol(self: *MachO, sym_with_loc: SymbolWithLoc) ?Atom.Index { |
| 3848 | 3878 | const stubs_index = self.stubs_table.get(sym_with_loc) orelse return null; |
| 3849 | | return self.stubs.items[stubs_index].getAtom(self); |
| 3879 | return self.stubs.items[stubs_index].getAtomIndex(self); |
| 3850 | 3880 | } |
| 3851 | 3881 | |
| 3852 | 3882 | /// Returns symbol location corresponding to the set entrypoint. |
| ... | ... | @@ -4232,26 +4262,31 @@ pub fn logAtoms(self: *MachO) void { |
| 4232 | 4262 | log.debug("atoms:", .{}); |
| 4233 | 4263 | |
| 4234 | 4264 | const slice = self.sections.slice(); |
| 4235 | | for (slice.items(.last_atom)) |last, i| { |
| 4236 | | var atom = last orelse continue; |
| 4265 | for (slice.items(.last_atom_index)) |last_atom_index, i| { |
| 4266 | var atom_index = last_atom_index orelse continue; |
| 4237 | 4267 | const header = slice.items(.header)[i]; |
| 4238 | 4268 | |
| 4239 | | while (atom.prev) |prev| { |
| 4240 | | atom = prev; |
| 4269 | while (true) { |
| 4270 | const atom = self.getAtom(atom_index); |
| 4271 | if (atom.prev_index) |prev_index| { |
| 4272 | atom_index = prev_index; |
| 4273 | } else break; |
| 4241 | 4274 | } |
| 4242 | 4275 | |
| 4243 | 4276 | log.debug("{s},{s}", .{ header.segName(), header.sectName() }); |
| 4244 | 4277 | |
| 4245 | 4278 | while (true) { |
| 4246 | | self.logAtom(atom); |
| 4247 | | if (atom.next) |next| { |
| 4248 | | atom = next; |
| 4279 | self.logAtom(atom_index); |
| 4280 | const atom = self.getAtom(atom_index); |
| 4281 | if (atom.next_index) |next_index| { |
| 4282 | atom_index = next_index; |
| 4249 | 4283 | } else break; |
| 4250 | 4284 | } |
| 4251 | 4285 | } |
| 4252 | 4286 | } |
| 4253 | 4287 | |
| 4254 | | pub fn logAtom(self: *MachO, atom: *const Atom) void { |
| 4288 | pub fn logAtom(self: *MachO, atom_index: Atom.Index) void { |
| 4289 | const atom = self.getAtom(atom_index); |
| 4255 | 4290 | const sym = atom.getSymbol(self); |
| 4256 | 4291 | const sym_name = atom.getName(self); |
| 4257 | 4292 | log.debug(" ATOM(%{?d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({?d}) in sect({d})", .{ |
Jakub Konka <kubkon@jakubkonka.com> 2023-01-30 18:22:50+01:00