| ... | @@ -1,1426 +0,0 @@ |
| 1 | //! This implementation does all the linking work in flush(). A future improvement |
| 2 | //! would be to add incremental linking in a similar way as ELF does. |
| 3 | |
| 4 | const Plan9 = @This(); |
| 5 | const link = @import("../link.zig"); |
| 6 | const Zcu = @import("../Zcu.zig"); |
| 7 | const InternPool = @import("../InternPool.zig"); |
| 8 | const Compilation = @import("../Compilation.zig"); |
| 9 | const aout = @import("Plan9/aout.zig"); |
| 10 | const codegen = @import("../codegen.zig"); |
| 11 | const trace = @import("../tracy.zig").trace; |
| 12 | const File = link.File; |
| 13 | const build_options = @import("build_options"); |
| 14 | const Air = @import("../Air.zig"); |
| 15 | const Type = @import("../Type.zig"); |
| 16 | const Value = @import("../Value.zig"); |
| 17 | const AnalUnit = InternPool.AnalUnit; |
| 18 | |
| 19 | const std = @import("std"); |
| 20 | const builtin = @import("builtin"); |
| 21 | const mem = std.mem; |
| 22 | const Allocator = std.mem.Allocator; |
| 23 | const log = std.log.scoped(.link); |
| 24 | const assert = std.debug.assert; |
| 25 | const Path = std.Build.Cache.Path; |
| 26 | |
| 27 | base: link.File, |
| 28 | sixtyfour_bit: bool, |
| 29 | bases: Bases, |
| 30 | |
| 31 | /// A symbol's value is just casted down when compiling |
| 32 | /// for a 32 bit target. |
| 33 | /// Does not represent the order or amount of symbols in the file |
| 34 | /// it is just useful for storing symbols. Some other symbols are in |
| 35 | /// file_segments. |
| 36 | syms: std.ArrayListUnmanaged(aout.Sym) = .empty, |
| 37 | |
| 38 | /// The plan9 a.out format requires segments of |
| 39 | /// filenames to be deduplicated, so we use this map to |
| 40 | /// de duplicate it. The value is the value of the path |
| 41 | /// component |
| 42 | file_segments: std.StringArrayHashMapUnmanaged(u16) = .empty, |
| 43 | /// The value of a 'f' symbol increments by 1 every time, so that no 2 'f' |
| 44 | /// symbols have the same value. |
| 45 | file_segments_i: u16 = 1, |
| 46 | |
| 47 | path_arena: std.heap.ArenaAllocator, |
| 48 | |
| 49 | /// maps a file scope to a hash map of decl to codegen output |
| 50 | /// this is useful for line debuginfo, since it makes sense to sort by file |
| 51 | /// The debugger looks for the first file (aout.Sym.Type.z) preceeding the text symbol |
| 52 | /// of the function to know what file it came from. |
| 53 | /// If we group the decls by file, it makes it really easy to do this (put the symbol in the correct place) |
| 54 | fn_nav_table: std.AutoArrayHashMapUnmanaged( |
| 55 | Zcu.File.Index, |
| 56 | struct { sym_index: u32, functions: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, FnNavOutput) = .empty }, |
| 57 | ) = .{}, |
| 58 | /// the code is modified when relocated, so that is why it is mutable |
| 59 | data_nav_table: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, []u8) = .empty, |
| 60 | /// When `updateExports` is called, we store the export indices here, to be used |
| 61 | /// during flush. |
| 62 | nav_exports: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, []Zcu.Export.Index) = .empty, |
| 63 | |
| 64 | lazy_syms: LazySymbolTable = .{}, |
| 65 | |
| 66 | uavs: std.AutoHashMapUnmanaged(InternPool.Index, Atom.Index) = .empty, |
| 67 | |
| 68 | relocs: std.AutoHashMapUnmanaged(Atom.Index, std.ArrayListUnmanaged(Reloc)) = .empty, |
| 69 | hdr: aout.ExecHdr = undefined, |
| 70 | |
| 71 | // relocs: std. |
| 72 | magic: u32, |
| 73 | |
| 74 | entry_val: ?u64 = null, |
| 75 | |
| 76 | got_len: usize = 0, |
| 77 | // A list of all the free got indexes, so when making a new decl |
| 78 | // don't make a new one, just use one from here. |
| 79 | got_index_free_list: std.ArrayListUnmanaged(usize) = .empty, |
| 80 | |
| 81 | syms_index_free_list: std.ArrayListUnmanaged(usize) = .empty, |
| 82 | |
| 83 | atoms: std.ArrayListUnmanaged(Atom) = .empty, |
| 84 | navs: std.AutoHashMapUnmanaged(InternPool.Nav.Index, NavMetadata) = .empty, |
| 85 | |
| 86 | /// Indices of the three "special" symbols into atoms |
| 87 | etext_edata_end_atom_indices: [3]?Atom.Index = .{ null, null, null }, |
| 88 | |
| 89 | const Reloc = struct { |
| 90 | target: Atom.Index, |
| 91 | offset: u64, |
| 92 | addend: u32, |
| 93 | type: enum { |
| 94 | pcrel, |
| 95 | nonpcrel, |
| 96 | // for getting the value of the etext symbol; we ignore target |
| 97 | special_etext, |
| 98 | // for getting the value of the edata symbol; we ignore target |
| 99 | special_edata, |
| 100 | // for getting the value of the end symbol; we ignore target |
| 101 | special_end, |
| 102 | } = .nonpcrel, |
| 103 | }; |
| 104 | |
| 105 | const Bases = struct { |
| 106 | text: u64, |
| 107 | /// the Global Offset Table starts at the beginning of the data section |
| 108 | data: u64, |
| 109 | }; |
| 110 | |
| 111 | const LazySymbolTable = std.AutoArrayHashMapUnmanaged(InternPool.Index, LazySymbolMetadata); |
| 112 | |
| 113 | const LazySymbolMetadata = struct { |
| 114 | const State = enum { unused, pending_flush, flushed }; |
| 115 | text_atom: Atom.Index = undefined, |
| 116 | rodata_atom: Atom.Index = undefined, |
| 117 | text_state: State = .unused, |
| 118 | rodata_state: State = .unused, |
| 119 | |
| 120 | fn numberOfAtoms(self: LazySymbolMetadata) u32 { |
| 121 | var n: u32 = 0; |
| 122 | if (self.text_state != .unused) n += 1; |
| 123 | if (self.rodata_state != .unused) n += 1; |
| 124 | return n; |
| 125 | } |
| 126 | }; |
| 127 | |
| 128 | pub const PtrWidth = enum { p32, p64 }; |
| 129 | |
| 130 | pub const Atom = struct { |
| 131 | type: aout.Sym.Type, |
| 132 | /// offset in the text or data sects |
| 133 | offset: ?u64, |
| 134 | /// offset into syms |
| 135 | sym_index: ?usize, |
| 136 | /// offset into got |
| 137 | got_index: ?usize, |
| 138 | /// We include the code here to be use in relocs |
| 139 | /// In the case of lazy_syms, this atom owns the code. |
| 140 | /// But, in the case of function and data decls, they own the code and this field |
| 141 | /// is just a pointer for convience. |
| 142 | code: CodePtr, |
| 143 | |
| 144 | const CodePtr = struct { |
| 145 | code_ptr: ?[*]u8, |
| 146 | other: union { |
| 147 | code_len: usize, |
| 148 | nav_index: InternPool.Nav.Index, |
| 149 | }, |
| 150 | fn fromSlice(slice: []u8) CodePtr { |
| 151 | return .{ .code_ptr = slice.ptr, .other = .{ .code_len = slice.len } }; |
| 152 | } |
| 153 | fn getCode(self: CodePtr, plan9: *const Plan9) []u8 { |
| 154 | const zcu = plan9.base.comp.zcu.?; |
| 155 | const ip = &zcu.intern_pool; |
| 156 | return if (self.code_ptr) |p| p[0..self.other.code_len] else blk: { |
| 157 | const nav_index = self.other.nav_index; |
| 158 | const nav = ip.getNav(nav_index); |
| 159 | if (ip.isFunctionType(nav.typeOf(ip))) { |
| 160 | const table = plan9.fn_nav_table.get(zcu.navFileScopeIndex(nav_index)).?.functions; |
| 161 | const output = table.get(nav_index).?; |
| 162 | break :blk output.code; |
| 163 | } else { |
| 164 | break :blk plan9.data_nav_table.get(nav_index).?; |
| 165 | } |
| 166 | }; |
| 167 | } |
| 168 | fn getOwnedCode(self: CodePtr) ?[]u8 { |
| 169 | return if (self.code_ptr) |p| p[0..self.other.code_len] else null; |
| 170 | } |
| 171 | }; |
| 172 | |
| 173 | pub const Index = u32; |
| 174 | |
| 175 | pub fn getOrCreateOffsetTableEntry(self: *Atom, plan9: *Plan9) usize { |
| 176 | if (self.got_index == null) self.got_index = plan9.allocateGotIndex(); |
| 177 | return self.got_index.?; |
| 178 | } |
| 179 | |
| 180 | pub fn getOrCreateSymbolTableEntry(self: *Atom, plan9: *Plan9) !usize { |
| 181 | if (self.sym_index == null) self.sym_index = try plan9.allocateSymbolIndex(); |
| 182 | return self.sym_index.?; |
| 183 | } |
| 184 | |
| 185 | // asserts that self.got_index != null |
| 186 | pub fn getOffsetTableAddress(self: Atom, plan9: *Plan9) u64 { |
| 187 | const target = &plan9.base.comp.root_mod.resolved_target.result; |
| 188 | const ptr_bytes = @divExact(target.ptrBitWidth(), 8); |
| 189 | const got_addr = plan9.bases.data; |
| 190 | const got_index = self.got_index.?; |
| 191 | return got_addr + got_index * ptr_bytes; |
| 192 | } |
| 193 | }; |
| 194 | |
| 195 | /// the plan9 debuginfo output is a bytecode with 4 opcodes |
| 196 | /// assume all numbers/variables are bytes |
| 197 | /// 0 w x y z -> interpret w x y z as a big-endian i32, and add it to the line offset |
| 198 | /// x when x < 65 -> add x to line offset |
| 199 | /// x when x < 129 -> subtract 64 from x and subtract it from the line offset |
| 200 | /// x -> subtract 129 from x, multiply it by the quanta of the instruction size |
| 201 | /// (1 on x86_64), and add it to the pc |
| 202 | /// after every opcode, add the quanta of the instruction size to the pc |
| 203 | pub const DebugInfoOutput = struct { |
| 204 | /// the actual opcodes |
| 205 | dbg_line: std.ArrayList(u8), |
| 206 | /// what line the debuginfo starts on |
| 207 | /// this helps because the linker might have to insert some opcodes to make sure that the line count starts at the right amount for the next decl |
| 208 | start_line: ?u32, |
| 209 | /// what the line count ends on after codegen |
| 210 | /// this helps because the linker might have to insert some opcodes to make sure that the line count starts at the right amount for the next decl |
| 211 | end_line: u32, |
| 212 | /// the last pc change op |
| 213 | /// This is very useful for adding quanta |
| 214 | /// to it if its not actually the last one. |
| 215 | pcop_change_index: ?u32, |
| 216 | /// cached pc quanta |
| 217 | pc_quanta: u8, |
| 218 | }; |
| 219 | |
| 220 | const NavMetadata = struct { |
| 221 | index: Atom.Index, |
| 222 | exports: std.ArrayListUnmanaged(usize) = .empty, |
| 223 | |
| 224 | fn getExport(m: NavMetadata, p9: *const Plan9, name: []const u8) ?usize { |
| 225 | for (m.exports.items) |exp| { |
| 226 | const sym = p9.syms.items[exp]; |
| 227 | if (mem.eql(u8, name, sym.name)) return exp; |
| 228 | } |
| 229 | return null; |
| 230 | } |
| 231 | }; |
| 232 | |
| 233 | const FnNavOutput = struct { |
| 234 | /// this code is modified when relocated so it is mutable |
| 235 | code: []u8, |
| 236 | /// this might have to be modified in the linker, so thats why its mutable |
| 237 | lineinfo: []u8, |
| 238 | start_line: u32, |
| 239 | end_line: u32, |
| 240 | }; |
| 241 | |
| 242 | fn getAddr(self: Plan9, addr: u64, t: aout.Sym.Type) u64 { |
| 243 | return addr + switch (t) { |
| 244 | .T, .t, .l, .L => self.bases.text, |
| 245 | .D, .d, .B, .b => self.bases.data, |
| 246 | else => unreachable, |
| 247 | }; |
| 248 | } |
| 249 | |
| 250 | fn getSymAddr(self: Plan9, s: aout.Sym) u64 { |
| 251 | return self.getAddr(s.value, s.type); |
| 252 | } |
| 253 | |
| 254 | pub fn defaultBaseAddrs(arch: std.Target.Cpu.Arch) Bases { |
| 255 | return switch (arch) { |
| 256 | .x86_64 => .{ |
| 257 | // header size => 40 => 0x28 |
| 258 | .text = 0x200028, |
| 259 | .data = 0x400000, |
| 260 | }, |
| 261 | .x86 => .{ |
| 262 | // header size => 32 => 0x20 |
| 263 | .text = 0x200020, |
| 264 | .data = 0x400000, |
| 265 | }, |
| 266 | .aarch64 => .{ |
| 267 | // header size => 40 => 0x28 |
| 268 | .text = 0x10028, |
| 269 | .data = 0x20000, |
| 270 | }, |
| 271 | else => std.debug.panic("find default base address for {}", .{arch}), |
| 272 | }; |
| 273 | } |
| 274 | |
| 275 | pub fn createEmpty( |
| 276 | arena: Allocator, |
| 277 | comp: *Compilation, |
| 278 | emit: Path, |
| 279 | options: link.File.OpenOptions, |
| 280 | ) !*Plan9 { |
| 281 | const target = &comp.root_mod.resolved_target.result; |
| 282 | const gpa = comp.gpa; |
| 283 | const optimize_mode = comp.root_mod.optimize_mode; |
| 284 | const output_mode = comp.config.output_mode; |
| 285 | |
| 286 | const sixtyfour_bit: bool = switch (target.ptrBitWidth()) { |
| 287 | 0...32 => false, |
| 288 | 33...64 => true, |
| 289 | else => return error.UnsupportedP9Architecture, |
| 290 | }; |
| 291 | |
| 292 | const self = try arena.create(Plan9); |
| 293 | self.* = .{ |
| 294 | .path_arena = std.heap.ArenaAllocator.init(gpa), |
| 295 | .base = .{ |
| 296 | .tag = .plan9, |
| 297 | .comp = comp, |
| 298 | .emit = emit, |
| 299 | .gc_sections = options.gc_sections orelse (optimize_mode != .Debug and output_mode != .Obj), |
| 300 | .print_gc_sections = options.print_gc_sections, |
| 301 | .stack_size = options.stack_size orelse 16777216, |
| 302 | .allow_shlib_undefined = options.allow_shlib_undefined orelse false, |
| 303 | .file = null, |
| 304 | .build_id = options.build_id, |
| 305 | }, |
| 306 | .sixtyfour_bit = sixtyfour_bit, |
| 307 | .bases = undefined, |
| 308 | .magic = try aout.magicFromArch(target.cpu.arch), |
| 309 | }; |
| 310 | // a / will always be in a file path |
| 311 | try self.file_segments.put(gpa, "/", 1); |
| 312 | return self; |
| 313 | } |
| 314 | |
| 315 | fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void { |
| 316 | const comp = self.base.comp; |
| 317 | const gpa = comp.gpa; |
| 318 | const zcu = comp.zcu.?; |
| 319 | const file_scope = zcu.navFileScopeIndex(nav_index); |
| 320 | const fn_map_res = try self.fn_nav_table.getOrPut(gpa, file_scope); |
| 321 | if (fn_map_res.found_existing) { |
| 322 | if (try fn_map_res.value_ptr.functions.fetchPut(gpa, nav_index, out)) |old_entry| { |
| 323 | gpa.free(old_entry.value.code); |
| 324 | gpa.free(old_entry.value.lineinfo); |
| 325 | } |
| 326 | } else { |
| 327 | const file = zcu.fileByIndex(file_scope); |
| 328 | const arena = self.path_arena.allocator(); |
| 329 | // each file gets a symbol |
| 330 | fn_map_res.value_ptr.* = .{ |
| 331 | .sym_index = blk: { |
| 332 | try self.syms.append(gpa, undefined); |
| 333 | try self.syms.append(gpa, undefined); |
| 334 | break :blk @as(u32, @intCast(self.syms.items.len - 1)); |
| 335 | }, |
| 336 | }; |
| 337 | try fn_map_res.value_ptr.functions.put(gpa, nav_index, out); |
| 338 | |
| 339 | var a = std.ArrayList(u8).init(arena); |
| 340 | errdefer a.deinit(); |
| 341 | // every 'z' starts with 0 |
| 342 | try a.append(0); |
| 343 | // path component value of '/' |
| 344 | try a.writer().writeInt(u16, 1, .big); |
| 345 | |
| 346 | // getting the full file path |
| 347 | { |
| 348 | const full_path = try file.path.toAbsolute(comp.dirs, gpa); |
| 349 | defer gpa.free(full_path); |
| 350 | try self.addPathComponents(full_path, &a); |
| 351 | } |
| 352 | |
| 353 | // null terminate |
| 354 | try a.append(0); |
| 355 | const final = try a.toOwnedSlice(); |
| 356 | self.syms.items[fn_map_res.value_ptr.sym_index - 1] = .{ |
| 357 | .type = .z, |
| 358 | .value = 1, |
| 359 | .name = final, |
| 360 | }; |
| 361 | self.syms.items[fn_map_res.value_ptr.sym_index] = .{ |
| 362 | .type = .z, |
| 363 | // just put a giant number, no source file will have this many newlines |
| 364 | .value = std.math.maxInt(u31), |
| 365 | .name = &.{ 0, 0 }, |
| 366 | }; |
| 367 | } |
| 368 | } |
| 369 | |
| 370 | fn addPathComponents(self: *Plan9, path: []const u8, a: *std.ArrayList(u8)) !void { |
| 371 | const gpa = self.base.comp.gpa; |
| 372 | const sep = std.fs.path.sep; |
| 373 | var it = std.mem.tokenizeScalar(u8, path, sep); |
| 374 | while (it.next()) |component| { |
| 375 | if (self.file_segments.get(component)) |num| { |
| 376 | try a.writer().writeInt(u16, num, .big); |
| 377 | } else { |
| 378 | self.file_segments_i += 1; |
| 379 | try self.file_segments.put(gpa, component, self.file_segments_i); |
| 380 | try a.writer().writeInt(u16, self.file_segments_i, .big); |
| 381 | } |
| 382 | } |
| 383 | } |
| 384 | |
| 385 | pub fn updateFunc( |
| 386 | self: *Plan9, |
| 387 | pt: Zcu.PerThread, |
| 388 | func_index: InternPool.Index, |
| 389 | mir: *const codegen.AnyMir, |
| 390 | ) link.File.UpdateNavError!void { |
| 391 | if (build_options.skip_non_native and builtin.object_format != .plan9) { |
| 392 | @panic("Attempted to compile for object format that was disabled by build configuration"); |
| 393 | } |
| 394 | |
| 395 | const zcu = pt.zcu; |
| 396 | const gpa = zcu.gpa; |
| 397 | const target = &self.base.comp.root_mod.resolved_target.result; |
| 398 | const func = zcu.funcInfo(func_index); |
| 399 | |
| 400 | const atom_idx = try self.seeNav(pt, func.owner_nav); |
| 401 | |
| 402 | var code_buffer: std.ArrayListUnmanaged(u8) = .empty; |
| 403 | defer code_buffer.deinit(gpa); |
| 404 | var dbg_info_output: DebugInfoOutput = .{ |
| 405 | .dbg_line = std.ArrayList(u8).init(gpa), |
| 406 | .start_line = null, |
| 407 | .end_line = undefined, |
| 408 | .pcop_change_index = null, |
| 409 | // we have already checked the target in the linker to make sure it is compatable |
| 410 | .pc_quanta = aout.getPCQuant(target.cpu.arch) catch unreachable, |
| 411 | }; |
| 412 | defer dbg_info_output.dbg_line.deinit(); |
| 413 | |
| 414 | try codegen.emitFunction( |
| 415 | &self.base, |
| 416 | pt, |
| 417 | zcu.navSrcLoc(func.owner_nav), |
| 418 | func_index, |
| 419 | mir, |
| 420 | &code_buffer, |
| 421 | .{ .plan9 = &dbg_info_output }, |
| 422 | ); |
| 423 | const code = try code_buffer.toOwnedSlice(gpa); |
| 424 | self.getAtomPtr(atom_idx).code = .{ |
| 425 | .code_ptr = null, |
| 426 | .other = .{ .nav_index = func.owner_nav }, |
| 427 | }; |
| 428 | const out: FnNavOutput = .{ |
| 429 | .code = code, |
| 430 | .lineinfo = try dbg_info_output.dbg_line.toOwnedSlice(), |
| 431 | .start_line = dbg_info_output.start_line.?, |
| 432 | .end_line = dbg_info_output.end_line, |
| 433 | }; |
| 434 | try self.putFn(func.owner_nav, out); |
| 435 | return self.updateFinish(pt, func.owner_nav); |
| 436 | } |
| 437 | |
| 438 | pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) link.File.UpdateNavError!void { |
| 439 | const zcu = pt.zcu; |
| 440 | const gpa = zcu.gpa; |
| 441 | const ip = &zcu.intern_pool; |
| 442 | const nav = ip.getNav(nav_index); |
| 443 | const nav_val = zcu.navValue(nav_index); |
| 444 | const nav_init = switch (ip.indexToKey(nav_val.toIntern())) { |
| 445 | .func => return, |
| 446 | .variable => |variable| Value.fromInterned(variable.init), |
| 447 | .@"extern" => { |
| 448 | log.debug("found extern decl: {f}", .{nav.name.fmt(ip)}); |
| 449 | return; |
| 450 | }, |
| 451 | else => nav_val, |
| 452 | }; |
| 453 | |
| 454 | if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) { |
| 455 | const atom_idx = try self.seeNav(pt, nav_index); |
| 456 | |
| 457 | var code_buffer: std.ArrayListUnmanaged(u8) = .empty; |
| 458 | defer code_buffer.deinit(gpa); |
| 459 | // TODO we need the symbol index for symbol in the table of locals for the containing atom |
| 460 | try codegen.generateSymbol( |
| 461 | &self.base, |
| 462 | pt, |
| 463 | zcu.navSrcLoc(nav_index), |
| 464 | nav_init, |
| 465 | &code_buffer, |
| 466 | .{ .atom_index = @intCast(atom_idx) }, |
| 467 | ); |
| 468 | const code = code_buffer.items; |
| 469 | try self.data_nav_table.ensureUnusedCapacity(gpa, 1); |
| 470 | const duped_code = try gpa.dupe(u8, code); |
| 471 | self.getAtomPtr(self.navs.get(nav_index).?.index).code = .{ .code_ptr = null, .other = .{ .nav_index = nav_index } }; |
| 472 | if (self.data_nav_table.fetchPutAssumeCapacity(nav_index, duped_code)) |old_entry| { |
| 473 | gpa.free(old_entry.value); |
| 474 | } |
| 475 | try self.updateFinish(pt, nav_index); |
| 476 | } |
| 477 | } |
| 478 | |
| 479 | /// called at the end of update{Decl,Func} |
| 480 | fn updateFinish(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void { |
| 481 | const zcu = pt.zcu; |
| 482 | const gpa = zcu.gpa; |
| 483 | const ip = &zcu.intern_pool; |
| 484 | const nav = ip.getNav(nav_index); |
| 485 | const is_fn = ip.isFunctionType(nav.typeOf(ip)); |
| 486 | const sym_t: aout.Sym.Type = if (is_fn) .t else .d; |
| 487 | |
| 488 | const atom = self.getAtomPtr(self.navs.get(nav_index).?.index); |
| 489 | // write the internal linker metadata |
| 490 | atom.type = sym_t; |
| 491 | // write the symbol |
| 492 | // we already have the got index |
| 493 | const sym: aout.Sym = .{ |
| 494 | .value = undefined, // the value of stuff gets filled in in flush |
| 495 | .type = atom.type, |
| 496 | .name = try gpa.dupe(u8, nav.name.toSlice(ip)), |
| 497 | }; |
| 498 | |
| 499 | if (atom.sym_index) |s| { |
| 500 | self.syms.items[s] = sym; |
| 501 | } else { |
| 502 | const s = try self.allocateSymbolIndex(); |
| 503 | atom.sym_index = s; |
| 504 | self.syms.items[s] = sym; |
| 505 | } |
| 506 | } |
| 507 | |
| 508 | fn allocateSymbolIndex(self: *Plan9) !usize { |
| 509 | const gpa = self.base.comp.gpa; |
| 510 | if (self.syms_index_free_list.pop()) |i| { |
| 511 | return i; |
| 512 | } else { |
| 513 | _ = try self.syms.addOne(gpa); |
| 514 | return self.syms.items.len - 1; |
| 515 | } |
| 516 | } |
| 517 | |
| 518 | fn allocateGotIndex(self: *Plan9) usize { |
| 519 | if (self.got_index_free_list.pop()) |i| { |
| 520 | return i; |
| 521 | } else { |
| 522 | self.got_len += 1; |
| 523 | return self.got_len - 1; |
| 524 | } |
| 525 | } |
| 526 | |
| 527 | pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void { |
| 528 | if (delta_line > 0 and delta_line < 65) { |
| 529 | const toappend = @as(u8, @intCast(delta_line)); |
| 530 | try l.append(toappend); |
| 531 | } else if (delta_line < 0 and delta_line > -65) { |
| 532 | const toadd: u8 = @as(u8, @intCast(-delta_line + 64)); |
| 533 | try l.append(toadd); |
| 534 | } else if (delta_line != 0) { |
| 535 | try l.append(0); |
| 536 | try l.writer().writeInt(i32, delta_line, .big); |
| 537 | } |
| 538 | } |
| 539 | |
| 540 | fn externCount(self: *Plan9) usize { |
| 541 | var extern_atom_count: usize = 0; |
| 542 | for (self.etext_edata_end_atom_indices) |idx| { |
| 543 | if (idx != null) extern_atom_count += 1; |
| 544 | } |
| 545 | return extern_atom_count; |
| 546 | } |
| 547 | // counts decls, and lazy syms |
| 548 | fn atomCount(self: *Plan9) usize { |
| 549 | var fn_nav_count: usize = 0; |
| 550 | var itf_files = self.fn_nav_table.iterator(); |
| 551 | while (itf_files.next()) |ent| { |
| 552 | // get the submap |
| 553 | var submap = ent.value_ptr.functions; |
| 554 | fn_nav_count += submap.count(); |
| 555 | } |
| 556 | const data_nav_count = self.data_nav_table.count(); |
| 557 | var lazy_atom_count: usize = 0; |
| 558 | var it_lazy = self.lazy_syms.iterator(); |
| 559 | while (it_lazy.next()) |kv| { |
| 560 | lazy_atom_count += kv.value_ptr.numberOfAtoms(); |
| 561 | } |
| 562 | const uav_atom_count = self.uavs.count(); |
| 563 | const extern_atom_count = self.externCount(); |
| 564 | return data_nav_count + fn_nav_count + lazy_atom_count + extern_atom_count + uav_atom_count; |
| 565 | } |
| 566 | |
| 567 | pub fn flush( |
| 568 | self: *Plan9, |
| 569 | arena: Allocator, |
| 570 | /// TODO: stop using this |
| 571 | tid: Zcu.PerThread.Id, |
| 572 | prog_node: std.Progress.Node, |
| 573 | ) link.File.FlushError!void { |
| 574 | if (build_options.skip_non_native and builtin.object_format != .plan9) { |
| 575 | @panic("Attempted to compile for object format that was disabled by build configuration"); |
| 576 | } |
| 577 | |
| 578 | const tracy = trace(@src()); |
| 579 | defer tracy.end(); |
| 580 | |
| 581 | _ = arena; // Has the same lifetime as the call to Compilation.update. |
| 582 | |
| 583 | const comp = self.base.comp; |
| 584 | const diags = &comp.link_diags; |
| 585 | const gpa = comp.gpa; |
| 586 | const target = &comp.root_mod.resolved_target.result; |
| 587 | |
| 588 | switch (comp.config.output_mode) { |
| 589 | .Exe => {}, |
| 590 | .Obj => return diags.fail("writing plan9 object files unimplemented", .{}), |
| 591 | .Lib => return diags.fail("writing plan9 lib files unimplemented", .{}), |
| 592 | } |
| 593 | |
| 594 | const sub_prog_node = prog_node.start("Flush Module", 0); |
| 595 | defer sub_prog_node.end(); |
| 596 | |
| 597 | log.debug("flush", .{}); |
| 598 | |
| 599 | defer assert(self.hdr.entry != 0x0); |
| 600 | |
| 601 | const pt: Zcu.PerThread = .activate( |
| 602 | self.base.comp.zcu orelse return diags.fail("linking without zig source unimplemented", .{}), |
| 603 | tid, |
| 604 | ); |
| 605 | defer pt.deactivate(); |
| 606 | |
| 607 | // finish up the lazy syms |
| 608 | if (self.lazy_syms.getPtr(.none)) |metadata| { |
| 609 | // Most lazy symbols can be updated on first use, but |
| 610 | // anyerror needs to wait for everything to be flushed. |
| 611 | if (metadata.text_state != .unused) try self.updateLazySymbolAtom( |
| 612 | pt, |
| 613 | .{ .kind = .code, .ty = .anyerror_type }, |
| 614 | metadata.text_atom, |
| 615 | ); |
| 616 | if (metadata.rodata_state != .unused) try self.updateLazySymbolAtom( |
| 617 | pt, |
| 618 | .{ .kind = .const_data, .ty = .anyerror_type }, |
| 619 | metadata.rodata_atom, |
| 620 | ); |
| 621 | } |
| 622 | for (self.lazy_syms.values()) |*metadata| { |
| 623 | if (metadata.text_state != .unused) metadata.text_state = .flushed; |
| 624 | if (metadata.rodata_state != .unused) metadata.rodata_state = .flushed; |
| 625 | } |
| 626 | // make sure the got table is good |
| 627 | const atom_count = self.atomCount(); |
| 628 | assert(self.got_len == atom_count + self.got_index_free_list.items.len); |
| 629 | const got_size = self.got_len * if (!self.sixtyfour_bit) @as(u32, 4) else 8; |
| 630 | var got_table = try gpa.alloc(u8, got_size); |
| 631 | defer gpa.free(got_table); |
| 632 | |
| 633 | // + 4 for header, got, symbols, linecountinfo |
| 634 | var iovecs = try gpa.alloc(std.posix.iovec_const, self.atomCount() + 4 - self.externCount()); |
| 635 | defer gpa.free(iovecs); |
| 636 | |
| 637 | const file = self.base.file.?; |
| 638 | |
| 639 | var hdr_buf: [40]u8 = undefined; |
| 640 | // account for the fat header |
| 641 | const hdr_size: usize = if (self.sixtyfour_bit) 40 else 32; |
| 642 | const hdr_slice: []u8 = hdr_buf[0..hdr_size]; |
| 643 | var foff = hdr_size; |
| 644 | iovecs[0] = .{ .base = hdr_slice.ptr, .len = hdr_slice.len }; |
| 645 | var iovecs_i: usize = 1; |
| 646 | var text_i: u64 = 0; |
| 647 | |
| 648 | var linecountinfo = std.ArrayList(u8).init(gpa); |
| 649 | defer linecountinfo.deinit(); |
| 650 | // text |
| 651 | { |
| 652 | var linecount: i64 = -1; |
| 653 | var it_file = self.fn_nav_table.iterator(); |
| 654 | while (it_file.next()) |fentry| { |
| 655 | var it = fentry.value_ptr.functions.iterator(); |
| 656 | while (it.next()) |entry| { |
| 657 | const nav_index = entry.key_ptr.*; |
| 658 | const nav = pt.zcu.intern_pool.getNav(nav_index); |
| 659 | const atom = self.getAtomPtr(self.navs.get(nav_index).?.index); |
| 660 | const out = entry.value_ptr.*; |
| 661 | { |
| 662 | // connect the previous decl to the next |
| 663 | const delta_line = @as(i32, @intCast(out.start_line)) - @as(i32, @intCast(linecount)); |
| 664 | |
| 665 | try changeLine(&linecountinfo, delta_line); |
| 666 | // TODO change the pc too (maybe?) |
| 667 | |
| 668 | // write out the actual info that was generated in codegen now |
| 669 | try linecountinfo.appendSlice(out.lineinfo); |
| 670 | linecount = out.end_line; |
| 671 | } |
| 672 | foff += out.code.len; |
| 673 | iovecs[iovecs_i] = .{ .base = out.code.ptr, .len = out.code.len }; |
| 674 | iovecs_i += 1; |
| 675 | const off = self.getAddr(text_i, .t); |
| 676 | text_i += out.code.len; |
| 677 | atom.offset = off; |
| 678 | log.debug("write text nav 0x{x} ({f}), lines {d} to {d}.;__GOT+0x{x} vaddr: 0x{x}", .{ nav_index, nav.name.fmt(&pt.zcu.intern_pool), out.start_line + 1, out.end_line, atom.got_index.? * 8, off }); |
| 679 | if (!self.sixtyfour_bit) { |
| 680 | mem.writeInt(u32, got_table[atom.got_index.? * 4 ..][0..4], @intCast(off), target.cpu.arch.endian()); |
| 681 | } else { |
| 682 | mem.writeInt(u64, got_table[atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian()); |
| 683 | } |
| 684 | self.syms.items[atom.sym_index.?].value = off; |
| 685 | if (self.nav_exports.get(nav_index)) |export_indices| { |
| 686 | try self.addNavExports(pt.zcu, nav_index, export_indices); |
| 687 | } |
| 688 | } |
| 689 | } |
| 690 | if (linecountinfo.items.len & 1 == 1) { |
| 691 | // just a nop to make it even, the plan9 linker does this |
| 692 | try linecountinfo.append(129); |
| 693 | } |
| 694 | } |
| 695 | // the text lazy symbols |
| 696 | { |
| 697 | var it = self.lazy_syms.iterator(); |
| 698 | while (it.next()) |kv| { |
| 699 | const meta = kv.value_ptr; |
| 700 | const text_atom = if (meta.text_state != .unused) self.getAtomPtr(meta.text_atom) else continue; |
| 701 | const code = text_atom.code.getOwnedCode().?; |
| 702 | foff += code.len; |
| 703 | iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len }; |
| 704 | iovecs_i += 1; |
| 705 | const off = self.getAddr(text_i, .t); |
| 706 | text_i += code.len; |
| 707 | text_atom.offset = off; |
| 708 | if (!self.sixtyfour_bit) { |
| 709 | mem.writeInt(u32, got_table[text_atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(off)), target.cpu.arch.endian()); |
| 710 | } else { |
| 711 | mem.writeInt(u64, got_table[text_atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian()); |
| 712 | } |
| 713 | self.syms.items[text_atom.sym_index.?].value = off; |
| 714 | } |
| 715 | } |
| 716 | // fix the sym for etext |
| 717 | if (self.etext_edata_end_atom_indices[0]) |etext_atom_idx| { |
| 718 | const etext_atom = self.getAtom(etext_atom_idx); |
| 719 | const val = self.getAddr(text_i, .t); |
| 720 | self.syms.items[etext_atom.sym_index.?].value = val; |
| 721 | if (!self.sixtyfour_bit) { |
| 722 | mem.writeInt(u32, got_table[etext_atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(val)), target.cpu.arch.endian()); |
| 723 | } else { |
| 724 | mem.writeInt(u64, got_table[etext_atom.got_index.? * 8 ..][0..8], val, target.cpu.arch.endian()); |
| 725 | } |
| 726 | } |
| 727 | // global offset table is in data |
| 728 | iovecs[iovecs_i] = .{ .base = got_table.ptr, .len = got_table.len }; |
| 729 | iovecs_i += 1; |
| 730 | // data |
| 731 | var data_i: u64 = got_size; |
| 732 | { |
| 733 | var it = self.data_nav_table.iterator(); |
| 734 | while (it.next()) |entry| { |
| 735 | const nav_index = entry.key_ptr.*; |
| 736 | const atom = self.getAtomPtr(self.navs.get(nav_index).?.index); |
| 737 | const code = entry.value_ptr.*; |
| 738 | |
| 739 | foff += code.len; |
| 740 | iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len }; |
| 741 | iovecs_i += 1; |
| 742 | const off = self.getAddr(data_i, .d); |
| 743 | data_i += code.len; |
| 744 | atom.offset = off; |
| 745 | if (!self.sixtyfour_bit) { |
| 746 | mem.writeInt(u32, got_table[atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(off)), target.cpu.arch.endian()); |
| 747 | } else { |
| 748 | mem.writeInt(u64, got_table[atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian()); |
| 749 | } |
| 750 | self.syms.items[atom.sym_index.?].value = off; |
| 751 | if (self.nav_exports.get(nav_index)) |export_indices| { |
| 752 | try self.addNavExports(pt.zcu, nav_index, export_indices); |
| 753 | } |
| 754 | } |
| 755 | { |
| 756 | var it_uav = self.uavs.iterator(); |
| 757 | while (it_uav.next()) |kv| { |
| 758 | const atom = self.getAtomPtr(kv.value_ptr.*); |
| 759 | const code = atom.code.getOwnedCode().?; |
| 760 | log.debug("write anon decl: {s}", .{self.syms.items[atom.sym_index.?].name}); |
| 761 | foff += code.len; |
| 762 | iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len }; |
| 763 | iovecs_i += 1; |
| 764 | const off = self.getAddr(data_i, .d); |
| 765 | data_i += code.len; |
| 766 | atom.offset = off; |
| 767 | if (!self.sixtyfour_bit) { |
| 768 | mem.writeInt(u32, got_table[atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(off)), target.cpu.arch.endian()); |
| 769 | } else { |
| 770 | mem.writeInt(u64, got_table[atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian()); |
| 771 | } |
| 772 | self.syms.items[atom.sym_index.?].value = off; |
| 773 | } |
| 774 | } |
| 775 | // the lazy data symbols |
| 776 | var it_lazy = self.lazy_syms.iterator(); |
| 777 | while (it_lazy.next()) |kv| { |
| 778 | const meta = kv.value_ptr; |
| 779 | const data_atom = if (meta.rodata_state != .unused) self.getAtomPtr(meta.rodata_atom) else continue; |
| 780 | const code = data_atom.code.getOwnedCode().?; // lazy symbols must own their code |
| 781 | foff += code.len; |
| 782 | iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len }; |
| 783 | iovecs_i += 1; |
| 784 | const off = self.getAddr(data_i, .d); |
| 785 | data_i += code.len; |
| 786 | data_atom.offset = off; |
| 787 | if (!self.sixtyfour_bit) { |
| 788 | mem.writeInt(u32, got_table[data_atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(off)), target.cpu.arch.endian()); |
| 789 | } else { |
| 790 | mem.writeInt(u64, got_table[data_atom.got_index.? * 8 ..][0..8], off, target.cpu.arch.endian()); |
| 791 | } |
| 792 | self.syms.items[data_atom.sym_index.?].value = off; |
| 793 | } |
| 794 | // edata symbol |
| 795 | if (self.etext_edata_end_atom_indices[1]) |edata_atom_idx| { |
| 796 | const edata_atom = self.getAtom(edata_atom_idx); |
| 797 | const val = self.getAddr(data_i, .b); |
| 798 | self.syms.items[edata_atom.sym_index.?].value = val; |
| 799 | if (!self.sixtyfour_bit) { |
| 800 | mem.writeInt(u32, got_table[edata_atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(val)), target.cpu.arch.endian()); |
| 801 | } else { |
| 802 | mem.writeInt(u64, got_table[edata_atom.got_index.? * 8 ..][0..8], val, target.cpu.arch.endian()); |
| 803 | } |
| 804 | } |
| 805 | // end symbol (same as edata because native backends don't do .bss yet) |
| 806 | if (self.etext_edata_end_atom_indices[2]) |end_atom_idx| { |
| 807 | const end_atom = self.getAtom(end_atom_idx); |
| 808 | const val = self.getAddr(data_i, .b); |
| 809 | self.syms.items[end_atom.sym_index.?].value = val; |
| 810 | if (!self.sixtyfour_bit) { |
| 811 | mem.writeInt(u32, got_table[end_atom.got_index.? * 4 ..][0..4], @as(u32, @intCast(val)), target.cpu.arch.endian()); |
| 812 | } else { |
| 813 | log.debug("write end (got_table[0x{x}] = 0x{x})", .{ end_atom.got_index.? * 8, val }); |
| 814 | mem.writeInt(u64, got_table[end_atom.got_index.? * 8 ..][0..8], val, target.cpu.arch.endian()); |
| 815 | } |
| 816 | } |
| 817 | } |
| 818 | var sym_buf = std.ArrayList(u8).init(gpa); |
| 819 | try self.writeSyms(&sym_buf); |
| 820 | const syms = try sym_buf.toOwnedSlice(); |
| 821 | defer gpa.free(syms); |
| 822 | assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls |
| 823 | iovecs[iovecs_i] = .{ .base = syms.ptr, .len = syms.len }; |
| 824 | iovecs_i += 1; |
| 825 | iovecs[iovecs_i] = .{ .base = linecountinfo.items.ptr, .len = linecountinfo.items.len }; |
| 826 | iovecs_i += 1; |
| 827 | // generate the header |
| 828 | self.hdr = .{ |
| 829 | .magic = self.magic, |
| 830 | .text = @as(u32, @intCast(text_i)), |
| 831 | .data = @as(u32, @intCast(data_i)), |
| 832 | .syms = @as(u32, @intCast(syms.len)), |
| 833 | .bss = 0, |
| 834 | .spsz = 0, |
| 835 | .pcsz = @as(u32, @intCast(linecountinfo.items.len)), |
| 836 | .entry = @as(u32, @intCast(self.entry_val.?)), |
| 837 | }; |
| 838 | @memcpy(hdr_slice, self.hdr.toU8s()[0..hdr_size]); |
| 839 | // write the fat header for 64 bit entry points |
| 840 | if (self.sixtyfour_bit) { |
| 841 | mem.writeInt(u64, hdr_buf[32..40], self.entry_val.?, .big); |
| 842 | } |
| 843 | // perform the relocs |
| 844 | { |
| 845 | var it = self.relocs.iterator(); |
| 846 | while (it.next()) |kv| { |
| 847 | const source_atom_index = kv.key_ptr.*; |
| 848 | const source_atom = self.getAtom(source_atom_index); |
| 849 | const source_atom_symbol = self.syms.items[source_atom.sym_index.?]; |
| 850 | const code = source_atom.code.getCode(self); |
| 851 | const endian = target.cpu.arch.endian(); |
| 852 | for (kv.value_ptr.items) |reloc| { |
| 853 | const offset = reloc.offset; |
| 854 | const addend = reloc.addend; |
| 855 | if (reloc.type == .pcrel or reloc.type == .nonpcrel) { |
| 856 | const target_atom_index = reloc.target; |
| 857 | const target_atom = self.getAtomPtr(target_atom_index); |
| 858 | const target_symbol = self.syms.items[target_atom.sym_index.?]; |
| 859 | const target_offset = target_atom.offset.?; |
| 860 | |
| 861 | switch (reloc.type) { |
| 862 | .pcrel => { |
| 863 | const disp = @as(i32, @intCast(target_offset)) - @as(i32, @intCast(source_atom.offset.?)) - 4 - @as(i32, @intCast(offset)); |
| 864 | mem.writeInt(i32, code[@as(usize, @intCast(offset))..][0..4], @as(i32, @intCast(disp)), endian); |
| 865 | }, |
| 866 | .nonpcrel => { |
| 867 | if (!self.sixtyfour_bit) { |
| 868 | mem.writeInt(u32, code[@intCast(offset)..][0..4], @as(u32, @intCast(target_offset + addend)), endian); |
| 869 | } else { |
| 870 | mem.writeInt(u64, code[@intCast(offset)..][0..8], target_offset + addend, endian); |
| 871 | } |
| 872 | }, |
| 873 | else => unreachable, |
| 874 | } |
| 875 | log.debug("relocating the address of '{s}' + {d} into '{s}' + {d} (({s}[{d}] = 0x{x} + 0x{x})", .{ target_symbol.name, addend, source_atom_symbol.name, offset, source_atom_symbol.name, offset, target_offset, addend }); |
| 876 | } else { |
| 877 | const addr = switch (reloc.type) { |
| 878 | .special_etext => self.syms.items[self.getAtom(self.etext_edata_end_atom_indices[0].?).sym_index.?].value, |
| 879 | .special_edata => self.syms.items[self.getAtom(self.etext_edata_end_atom_indices[1].?).sym_index.?].value, |
| 880 | .special_end => self.syms.items[self.getAtom(self.etext_edata_end_atom_indices[2].?).sym_index.?].value, |
| 881 | else => unreachable, |
| 882 | }; |
| 883 | if (!self.sixtyfour_bit) { |
| 884 | mem.writeInt(u32, code[@intCast(offset)..][0..4], @as(u32, @intCast(addr + addend)), endian); |
| 885 | } else { |
| 886 | mem.writeInt(u64, code[@intCast(offset)..][0..8], addr + addend, endian); |
| 887 | } |
| 888 | log.debug("relocating the address of '{s}' + {d} into '{s}' + {d} (({s}[{d}] = 0x{x} + 0x{x})", .{ @tagName(reloc.type), addend, source_atom_symbol.name, offset, source_atom_symbol.name, offset, addr, addend }); |
| 889 | } |
| 890 | } |
| 891 | } |
| 892 | } |
| 893 | file.pwritevAll(iovecs, 0) catch |err| return diags.fail("failed to write file: {s}", .{@errorName(err)}); |
| 894 | } |
| 895 | fn addNavExports( |
| 896 | self: *Plan9, |
| 897 | zcu: *Zcu, |
| 898 | nav_index: InternPool.Nav.Index, |
| 899 | export_indices: []const Zcu.Export.Index, |
| 900 | ) !void { |
| 901 | const gpa = self.base.comp.gpa; |
| 902 | const metadata = self.navs.getPtr(nav_index).?; |
| 903 | const atom = self.getAtom(metadata.index); |
| 904 | |
| 905 | for (export_indices) |export_idx| { |
| 906 | const exp = export_idx.ptr(zcu); |
| 907 | const exp_name = exp.opts.name.toSlice(&zcu.intern_pool); |
| 908 | // plan9 does not support custom sections |
| 909 | if (exp.opts.section.unwrap()) |section_name| { |
| 910 | if (!section_name.eqlSlice(".text", &zcu.intern_pool) and |
| 911 | !section_name.eqlSlice(".data", &zcu.intern_pool)) |
| 912 | { |
| 913 | try zcu.failed_exports.put(zcu.gpa, export_idx, try Zcu.ErrorMsg.create( |
| 914 | gpa, |
| 915 | zcu.navSrcLoc(nav_index), |
| 916 | "plan9 does not support extra sections", |
| 917 | .{}, |
| 918 | )); |
| 919 | break; |
| 920 | } |
| 921 | } |
| 922 | const sym: aout.Sym = .{ |
| 923 | .value = atom.offset.?, |
| 924 | .type = atom.type.toGlobal(), |
| 925 | .name = try gpa.dupe(u8, exp_name), |
| 926 | }; |
| 927 | |
| 928 | if (metadata.getExport(self, exp_name)) |i| { |
| 929 | self.syms.items[i] = sym; |
| 930 | } else { |
| 931 | try self.syms.append(gpa, sym); |
| 932 | try metadata.exports.append(gpa, self.syms.items.len - 1); |
| 933 | } |
| 934 | } |
| 935 | } |
| 936 | |
| 937 | fn createAtom(self: *Plan9) !Atom.Index { |
| 938 | const gpa = self.base.comp.gpa; |
| 939 | const index = @as(Atom.Index, @intCast(self.atoms.items.len)); |
| 940 | const atom = try self.atoms.addOne(gpa); |
| 941 | atom.* = .{ |
| 942 | .type = .t, |
| 943 | .offset = null, |
| 944 | .sym_index = null, |
| 945 | .got_index = null, |
| 946 | .code = undefined, |
| 947 | }; |
| 948 | return index; |
| 949 | } |
| 950 | |
| 951 | pub fn seeNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !Atom.Index { |
| 952 | const zcu = pt.zcu; |
| 953 | const ip = &zcu.intern_pool; |
| 954 | const gpa = zcu.gpa; |
| 955 | const gop = try self.navs.getOrPut(gpa, nav_index); |
| 956 | if (!gop.found_existing) { |
| 957 | const index = try self.createAtom(); |
| 958 | self.getAtomPtr(index).got_index = self.allocateGotIndex(); |
| 959 | gop.value_ptr.* = .{ |
| 960 | .index = index, |
| 961 | .exports = .{}, |
| 962 | }; |
| 963 | } |
| 964 | const atom_idx = gop.value_ptr.index; |
| 965 | // handle externs here because they might not get updateDecl called on them |
| 966 | const nav = ip.getNav(nav_index); |
| 967 | if (nav.getExtern(ip) != null) { |
| 968 | // this is a "phantom atom" - it is never actually written to disk, just convenient for us to store stuff about externs |
| 969 | if (nav.name.eqlSlice("etext", ip)) { |
| 970 | self.etext_edata_end_atom_indices[0] = atom_idx; |
| 971 | } else if (nav.name.eqlSlice("edata", ip)) { |
| 972 | self.etext_edata_end_atom_indices[1] = atom_idx; |
| 973 | } else if (nav.name.eqlSlice("end", ip)) { |
| 974 | self.etext_edata_end_atom_indices[2] = atom_idx; |
| 975 | } |
| 976 | try self.updateFinish(pt, nav_index); |
| 977 | log.debug("seeNav(extern) for {f} (got_addr=0x{x})", .{ |
| 978 | nav.name.fmt(ip), |
| 979 | self.getAtom(atom_idx).getOffsetTableAddress(self), |
| 980 | }); |
| 981 | } else log.debug("seeNav for {f}", .{nav.name.fmt(ip)}); |
| 982 | return atom_idx; |
| 983 | } |
| 984 | |
| 985 | pub fn updateExports( |
| 986 | self: *Plan9, |
| 987 | pt: Zcu.PerThread, |
| 988 | exported: Zcu.Exported, |
| 989 | export_indices: []const Zcu.Export.Index, |
| 990 | ) !void { |
| 991 | const gpa = self.base.comp.gpa; |
| 992 | switch (exported) { |
| 993 | .uav => @panic("TODO: plan9 updateExports handling values"), |
| 994 | .nav => |nav| { |
| 995 | _ = try self.seeNav(pt, nav); |
| 996 | if (self.nav_exports.fetchSwapRemove(nav)) |kv| { |
| 997 | gpa.free(kv.value); |
| 998 | } |
| 999 | try self.nav_exports.ensureUnusedCapacity(gpa, 1); |
| 1000 | const duped_indices = try gpa.dupe(Zcu.Export.Index, export_indices); |
| 1001 | self.nav_exports.putAssumeCapacityNoClobber(nav, duped_indices); |
| 1002 | }, |
| 1003 | } |
| 1004 | // all proper work is done in flush |
| 1005 | } |
| 1006 | |
| 1007 | pub fn getOrCreateAtomForLazySymbol(self: *Plan9, pt: Zcu.PerThread, lazy_sym: File.LazySymbol) !Atom.Index { |
| 1008 | const gop = try self.lazy_syms.getOrPut(pt.zcu.gpa, lazy_sym.ty); |
| 1009 | errdefer _ = if (!gop.found_existing) self.lazy_syms.pop(); |
| 1010 | |
| 1011 | if (!gop.found_existing) gop.value_ptr.* = .{}; |
| 1012 | |
| 1013 | const atom_ptr, const state_ptr = switch (lazy_sym.kind) { |
| 1014 | .code => .{ &gop.value_ptr.text_atom, &gop.value_ptr.text_state }, |
| 1015 | .const_data => .{ &gop.value_ptr.rodata_atom, &gop.value_ptr.rodata_state }, |
| 1016 | }; |
| 1017 | switch (state_ptr.*) { |
| 1018 | .unused => atom_ptr.* = try self.createAtom(), |
| 1019 | .pending_flush => return atom_ptr.*, |
| 1020 | .flushed => {}, |
| 1021 | } |
| 1022 | state_ptr.* = .pending_flush; |
| 1023 | const atom = atom_ptr.*; |
| 1024 | _ = try self.getAtomPtr(atom).getOrCreateSymbolTableEntry(self); |
| 1025 | _ = self.getAtomPtr(atom).getOrCreateOffsetTableEntry(self); |
| 1026 | // anyerror needs to be deferred until flush |
| 1027 | if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbolAtom(pt, lazy_sym, atom); |
| 1028 | return atom; |
| 1029 | } |
| 1030 | |
| 1031 | fn updateLazySymbolAtom( |
| 1032 | self: *Plan9, |
| 1033 | pt: Zcu.PerThread, |
| 1034 | sym: File.LazySymbol, |
| 1035 | atom_index: Atom.Index, |
| 1036 | ) error{ LinkFailure, OutOfMemory }!void { |
| 1037 | const gpa = pt.zcu.gpa; |
| 1038 | const comp = self.base.comp; |
| 1039 | const diags = &comp.link_diags; |
| 1040 | |
| 1041 | var required_alignment: InternPool.Alignment = .none; |
| 1042 | var code_buffer: std.ArrayListUnmanaged(u8) = .empty; |
| 1043 | defer code_buffer.deinit(gpa); |
| 1044 | |
| 1045 | // create the symbol for the name |
| 1046 | const name = try std.fmt.allocPrint(gpa, "__lazy_{s}_{f}", .{ |
| 1047 | @tagName(sym.kind), |
| 1048 | Type.fromInterned(sym.ty).fmt(pt), |
| 1049 | }); |
| 1050 | |
| 1051 | const symbol: aout.Sym = .{ |
| 1052 | .value = undefined, |
| 1053 | .type = if (sym.kind == .code) .t else .d, |
| 1054 | .name = name, |
| 1055 | }; |
| 1056 | self.syms.items[self.getAtomPtr(atom_index).sym_index.?] = symbol; |
| 1057 | |
| 1058 | // generate the code |
| 1059 | const src = Type.fromInterned(sym.ty).srcLocOrNull(pt.zcu) orelse Zcu.LazySrcLoc.unneeded; |
| 1060 | codegen.generateLazySymbol( |
| 1061 | &self.base, |
| 1062 | pt, |
| 1063 | src, |
| 1064 | sym, |
| 1065 | &required_alignment, |
| 1066 | &code_buffer, |
| 1067 | .none, |
| 1068 | .{ .atom_index = @intCast(atom_index) }, |
| 1069 | ) catch |err| switch (err) { |
| 1070 | error.OutOfMemory => return error.OutOfMemory, |
| 1071 | error.CodegenFail => return error.LinkFailure, |
| 1072 | error.Overflow, |
| 1073 | error.RelocationNotByteAligned, |
| 1074 | => return diags.fail("unable to codegen: {s}", .{@errorName(err)}), |
| 1075 | }; |
| 1076 | const code = code_buffer.items; |
| 1077 | // duped_code is freed when the atom is freed |
| 1078 | const duped_code = try gpa.dupe(u8, code); |
| 1079 | errdefer gpa.free(duped_code); |
| 1080 | self.getAtomPtr(atom_index).code = .{ |
| 1081 | .code_ptr = duped_code.ptr, |
| 1082 | .other = .{ .code_len = duped_code.len }, |
| 1083 | }; |
| 1084 | } |
| 1085 | |
| 1086 | pub fn deinit(self: *Plan9) void { |
| 1087 | const gpa = self.base.comp.gpa; |
| 1088 | { |
| 1089 | var it = self.relocs.valueIterator(); |
| 1090 | while (it.next()) |relocs| { |
| 1091 | relocs.deinit(gpa); |
| 1092 | } |
| 1093 | self.relocs.deinit(gpa); |
| 1094 | } |
| 1095 | var it_lzc = self.lazy_syms.iterator(); |
| 1096 | while (it_lzc.next()) |kv| { |
| 1097 | if (kv.value_ptr.text_state != .unused) |
| 1098 | gpa.free(self.syms.items[self.getAtom(kv.value_ptr.text_atom).sym_index.?].name); |
| 1099 | if (kv.value_ptr.rodata_state != .unused) |
| 1100 | gpa.free(self.syms.items[self.getAtom(kv.value_ptr.rodata_atom).sym_index.?].name); |
| 1101 | } |
| 1102 | self.lazy_syms.deinit(gpa); |
| 1103 | var itf_files = self.fn_nav_table.iterator(); |
| 1104 | while (itf_files.next()) |ent| { |
| 1105 | // get the submap |
| 1106 | var submap = ent.value_ptr.functions; |
| 1107 | defer submap.deinit(gpa); |
| 1108 | var itf = submap.iterator(); |
| 1109 | while (itf.next()) |entry| { |
| 1110 | gpa.free(entry.value_ptr.code); |
| 1111 | gpa.free(entry.value_ptr.lineinfo); |
| 1112 | } |
| 1113 | } |
| 1114 | self.fn_nav_table.deinit(gpa); |
| 1115 | var itd = self.data_nav_table.iterator(); |
| 1116 | while (itd.next()) |entry| { |
| 1117 | gpa.free(entry.value_ptr.*); |
| 1118 | } |
| 1119 | var it_uav = self.uavs.iterator(); |
| 1120 | while (it_uav.next()) |entry| { |
| 1121 | const sym_index = self.getAtom(entry.value_ptr.*).sym_index.?; |
| 1122 | gpa.free(self.syms.items[sym_index].name); |
| 1123 | } |
| 1124 | self.data_nav_table.deinit(gpa); |
| 1125 | for (self.nav_exports.values()) |export_indices| { |
| 1126 | gpa.free(export_indices); |
| 1127 | } |
| 1128 | self.nav_exports.deinit(gpa); |
| 1129 | self.syms.deinit(gpa); |
| 1130 | self.got_index_free_list.deinit(gpa); |
| 1131 | self.syms_index_free_list.deinit(gpa); |
| 1132 | self.file_segments.deinit(gpa); |
| 1133 | self.path_arena.deinit(); |
| 1134 | for (self.atoms.items) |a| { |
| 1135 | if (a.code.getOwnedCode()) |c| { |
| 1136 | gpa.free(c); |
| 1137 | } |
| 1138 | } |
| 1139 | self.atoms.deinit(gpa); |
| 1140 | |
| 1141 | { |
| 1142 | var it = self.navs.iterator(); |
| 1143 | while (it.next()) |entry| { |
| 1144 | entry.value_ptr.exports.deinit(gpa); |
| 1145 | } |
| 1146 | self.navs.deinit(gpa); |
| 1147 | } |
| 1148 | } |
| 1149 | |
| 1150 | pub fn open( |
| 1151 | arena: Allocator, |
| 1152 | comp: *Compilation, |
| 1153 | emit: Path, |
| 1154 | options: link.File.OpenOptions, |
| 1155 | ) !*Plan9 { |
| 1156 | const target = &comp.root_mod.resolved_target.result; |
| 1157 | const use_lld = build_options.have_llvm and comp.config.use_lld; |
| 1158 | const use_llvm = comp.config.use_llvm; |
| 1159 | |
| 1160 | assert(!use_llvm); // Caught by Compilation.Config.resolve. |
| 1161 | assert(!use_lld); // Caught by Compilation.Config.resolve. |
| 1162 | assert(target.ofmt == .plan9); |
| 1163 | |
| 1164 | const self = try createEmpty(arena, comp, emit, options); |
| 1165 | errdefer self.base.destroy(); |
| 1166 | |
| 1167 | const file = try emit.root_dir.handle.createFile(emit.sub_path, .{ |
| 1168 | .read = true, |
| 1169 | .mode = link.File.determineMode(comp.config.output_mode, comp.config.link_mode), |
| 1170 | }); |
| 1171 | errdefer file.close(); |
| 1172 | self.base.file = file; |
| 1173 | |
| 1174 | self.bases = defaultBaseAddrs(target.cpu.arch); |
| 1175 | |
| 1176 | const gpa = comp.gpa; |
| 1177 | |
| 1178 | try self.syms.appendSlice(gpa, &.{ |
| 1179 | // we include the global offset table to make it easier for debugging |
| 1180 | .{ |
| 1181 | .value = self.getAddr(0, .d), // the global offset table starts at 0 |
| 1182 | .type = .d, |
| 1183 | .name = "__GOT", |
| 1184 | }, |
| 1185 | }); |
| 1186 | |
| 1187 | return self; |
| 1188 | } |
| 1189 | |
| 1190 | pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void { |
| 1191 | // log.debug("write sym{{name: {s}, value: {x}}}", .{ sym.name, sym.value }); |
| 1192 | if (sym.type == .bad) return; // we don't want to write free'd symbols |
| 1193 | if (!self.sixtyfour_bit) { |
| 1194 | try w.writeInt(u32, @as(u32, @intCast(sym.value)), .big); |
| 1195 | } else { |
| 1196 | try w.writeInt(u64, sym.value, .big); |
| 1197 | } |
| 1198 | try w.writeByte(@intFromEnum(sym.type)); |
| 1199 | try w.writeAll(sym.name); |
| 1200 | try w.writeByte(0); |
| 1201 | } |
| 1202 | |
| 1203 | pub fn writeSyms(self: *Plan9, buf: *std.ArrayList(u8)) !void { |
| 1204 | const zcu = self.base.comp.zcu.?; |
| 1205 | const ip = &zcu.intern_pool; |
| 1206 | const writer = buf.writer(); |
| 1207 | // write __GOT |
| 1208 | try self.writeSym(writer, self.syms.items[0]); |
| 1209 | // write the f symbols |
| 1210 | { |
| 1211 | var it = self.file_segments.iterator(); |
| 1212 | while (it.next()) |entry| { |
| 1213 | try self.writeSym(writer, .{ |
| 1214 | .type = .f, |
| 1215 | .value = entry.value_ptr.*, |
| 1216 | .name = entry.key_ptr.*, |
| 1217 | }); |
| 1218 | } |
| 1219 | } |
| 1220 | |
| 1221 | // write the data symbols |
| 1222 | { |
| 1223 | var it = self.data_nav_table.iterator(); |
| 1224 | while (it.next()) |entry| { |
| 1225 | const nav_index = entry.key_ptr.*; |
| 1226 | const nav_metadata = self.navs.get(nav_index).?; |
| 1227 | const atom = self.getAtom(nav_metadata.index); |
| 1228 | const sym = self.syms.items[atom.sym_index.?]; |
| 1229 | try self.writeSym(writer, sym); |
| 1230 | if (self.nav_exports.get(nav_index)) |export_indices| { |
| 1231 | for (export_indices) |export_idx| { |
| 1232 | const exp = export_idx.ptr(zcu); |
| 1233 | if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) |exp_i| { |
| 1234 | try self.writeSym(writer, self.syms.items[exp_i]); |
| 1235 | } |
| 1236 | } |
| 1237 | } |
| 1238 | } |
| 1239 | } |
| 1240 | // the data lazy symbols |
| 1241 | { |
| 1242 | var it = self.lazy_syms.iterator(); |
| 1243 | while (it.next()) |kv| { |
| 1244 | const meta = kv.value_ptr; |
| 1245 | const data_atom = if (meta.rodata_state != .unused) self.getAtomPtr(meta.rodata_atom) else continue; |
| 1246 | const sym = self.syms.items[data_atom.sym_index.?]; |
| 1247 | try self.writeSym(writer, sym); |
| 1248 | } |
| 1249 | } |
| 1250 | // text symbols are the hardest: |
| 1251 | // the file of a text symbol is the .z symbol before it |
| 1252 | // so we have to write everything in the right order |
| 1253 | { |
| 1254 | var it_file = self.fn_nav_table.iterator(); |
| 1255 | while (it_file.next()) |fentry| { |
| 1256 | var symidx_and_submap = fentry.value_ptr; |
| 1257 | // write the z symbols |
| 1258 | try self.writeSym(writer, self.syms.items[symidx_and_submap.sym_index - 1]); |
| 1259 | try self.writeSym(writer, self.syms.items[symidx_and_submap.sym_index]); |
| 1260 | |
| 1261 | // write all the decls come from the file of the z symbol |
| 1262 | var submap_it = symidx_and_submap.functions.iterator(); |
| 1263 | while (submap_it.next()) |entry| { |
| 1264 | const nav_index = entry.key_ptr.*; |
| 1265 | const nav_metadata = self.navs.get(nav_index).?; |
| 1266 | const atom = self.getAtom(nav_metadata.index); |
| 1267 | const sym = self.syms.items[atom.sym_index.?]; |
| 1268 | try self.writeSym(writer, sym); |
| 1269 | if (self.nav_exports.get(nav_index)) |export_indices| { |
| 1270 | for (export_indices) |export_idx| { |
| 1271 | const exp = export_idx.ptr(zcu); |
| 1272 | if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) |exp_i| { |
| 1273 | const s = self.syms.items[exp_i]; |
| 1274 | if (mem.eql(u8, s.name, "_start")) |
| 1275 | self.entry_val = s.value; |
| 1276 | try self.writeSym(writer, s); |
| 1277 | } |
| 1278 | } |
| 1279 | } |
| 1280 | } |
| 1281 | } |
| 1282 | // the text lazy symbols |
| 1283 | { |
| 1284 | var it = self.lazy_syms.iterator(); |
| 1285 | while (it.next()) |kv| { |
| 1286 | const meta = kv.value_ptr; |
| 1287 | const text_atom = if (meta.text_state != .unused) self.getAtomPtr(meta.text_atom) else continue; |
| 1288 | const sym = self.syms.items[text_atom.sym_index.?]; |
| 1289 | try self.writeSym(writer, sym); |
| 1290 | } |
| 1291 | } |
| 1292 | } |
| 1293 | // special symbols |
| 1294 | for (self.etext_edata_end_atom_indices) |idx| { |
| 1295 | if (idx) |atom_idx| { |
| 1296 | const atom = self.getAtom(atom_idx); |
| 1297 | const sym = self.syms.items[atom.sym_index.?]; |
| 1298 | try self.writeSym(writer, sym); |
| 1299 | } |
| 1300 | } |
| 1301 | } |
| 1302 | |
| 1303 | pub fn updateLineNumber(self: *Plan9, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) !void { |
| 1304 | _ = self; |
| 1305 | _ = pt; |
| 1306 | _ = ti_id; |
| 1307 | } |
| 1308 | |
| 1309 | pub fn getNavVAddr( |
| 1310 | self: *Plan9, |
| 1311 | pt: Zcu.PerThread, |
| 1312 | nav_index: InternPool.Nav.Index, |
| 1313 | reloc_info: link.File.RelocInfo, |
| 1314 | ) !u64 { |
| 1315 | const ip = &pt.zcu.intern_pool; |
| 1316 | const nav = ip.getNav(nav_index); |
| 1317 | log.debug("getDeclVAddr for {f}", .{nav.name.fmt(ip)}); |
| 1318 | if (nav.getExtern(ip) != null) { |
| 1319 | if (nav.name.eqlSlice("etext", ip)) { |
| 1320 | try self.addReloc(reloc_info.parent.atom_index, .{ |
| 1321 | .target = undefined, |
| 1322 | .offset = reloc_info.offset, |
| 1323 | .addend = reloc_info.addend, |
| 1324 | .type = .special_etext, |
| 1325 | }); |
| 1326 | } else if (nav.name.eqlSlice("edata", ip)) { |
| 1327 | try self.addReloc(reloc_info.parent.atom_index, .{ |
| 1328 | .target = undefined, |
| 1329 | .offset = reloc_info.offset, |
| 1330 | .addend = reloc_info.addend, |
| 1331 | .type = .special_edata, |
| 1332 | }); |
| 1333 | } else if (nav.name.eqlSlice("end", ip)) { |
| 1334 | try self.addReloc(reloc_info.parent.atom_index, .{ |
| 1335 | .target = undefined, |
| 1336 | .offset = reloc_info.offset, |
| 1337 | .addend = reloc_info.addend, |
| 1338 | .type = .special_end, |
| 1339 | }); |
| 1340 | } |
| 1341 | // TODO handle other extern variables and functions |
| 1342 | return undefined; |
| 1343 | } |
| 1344 | // otherwise, we just add a relocation |
| 1345 | const atom_index = try self.seeNav(pt, nav_index); |
| 1346 | // the parent_atom_index in this case is just the decl_index of the parent |
| 1347 | try self.addReloc(reloc_info.parent.atom_index, .{ |
| 1348 | .target = atom_index, |
| 1349 | .offset = reloc_info.offset, |
| 1350 | .addend = reloc_info.addend, |
| 1351 | }); |
| 1352 | return undefined; |
| 1353 | } |
| 1354 | |
| 1355 | pub fn lowerUav( |
| 1356 | self: *Plan9, |
| 1357 | pt: Zcu.PerThread, |
| 1358 | uav: InternPool.Index, |
| 1359 | explicit_alignment: InternPool.Alignment, |
| 1360 | src_loc: Zcu.LazySrcLoc, |
| 1361 | ) !codegen.SymbolResult { |
| 1362 | _ = explicit_alignment; |
| 1363 | // example: |
| 1364 | // const ty = mod.intern_pool.typeOf(decl_val).toType(); |
| 1365 | // const val = decl_val.toValue(); |
| 1366 | // The symbol name can be something like `__anon_{d}` with `@intFromEnum(decl_val)`. |
| 1367 | // It doesn't have an owner decl because it's just an unnamed constant that might |
| 1368 | // be used by more than one function, however, its address is being used so we need |
| 1369 | // to put it in some location. |
| 1370 | // ... |
| 1371 | const gpa = self.base.comp.gpa; |
| 1372 | const gop = try self.uavs.getOrPut(gpa, uav); |
| 1373 | if (gop.found_existing) return .{ .sym_index = gop.value_ptr.* }; |
| 1374 | const val = Value.fromInterned(uav); |
| 1375 | const name = try std.fmt.allocPrint(gpa, "__anon_{d}", .{@intFromEnum(uav)}); |
| 1376 | |
| 1377 | const index = try self.createAtom(); |
| 1378 | const got_index = self.allocateGotIndex(); |
| 1379 | gop.value_ptr.* = index; |
| 1380 | // we need to free name latex |
| 1381 | var code_buffer: std.ArrayListUnmanaged(u8) = .empty; |
| 1382 | defer code_buffer.deinit(gpa); |
| 1383 | try codegen.generateSymbol(&self.base, pt, src_loc, val, &code_buffer, .{ .atom_index = index }); |
| 1384 | const atom_ptr = self.getAtomPtr(index); |
| 1385 | atom_ptr.* = .{ |
| 1386 | .type = .d, |
| 1387 | .offset = undefined, |
| 1388 | .sym_index = null, |
| 1389 | .got_index = got_index, |
| 1390 | .code = Atom.CodePtr.fromSlice(try code_buffer.toOwnedSlice(gpa)), |
| 1391 | }; |
| 1392 | _ = try atom_ptr.getOrCreateSymbolTableEntry(self); |
| 1393 | self.syms.items[atom_ptr.sym_index.?] = .{ |
| 1394 | .type = .d, |
| 1395 | .value = undefined, |
| 1396 | .name = name, |
| 1397 | }; |
| 1398 | return .{ .sym_index = index }; |
| 1399 | } |
| 1400 | |
| 1401 | pub fn getUavVAddr(self: *Plan9, uav: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 { |
| 1402 | const atom_index = self.uavs.get(uav).?; |
| 1403 | try self.addReloc(reloc_info.parent.atom_index, .{ |
| 1404 | .target = atom_index, |
| 1405 | .offset = reloc_info.offset, |
| 1406 | .addend = reloc_info.addend, |
| 1407 | }); |
| 1408 | return undefined; |
| 1409 | } |
| 1410 | |
| 1411 | pub fn addReloc(self: *Plan9, parent_index: Atom.Index, reloc: Reloc) !void { |
| 1412 | const gpa = self.base.comp.gpa; |
| 1413 | const gop = try self.relocs.getOrPut(gpa, parent_index); |
| 1414 | if (!gop.found_existing) { |
| 1415 | gop.value_ptr.* = .{}; |
| 1416 | } |
| 1417 | try gop.value_ptr.append(gpa, reloc); |
| 1418 | } |
| 1419 | |
| 1420 | pub fn getAtom(self: *const Plan9, index: Atom.Index) Atom { |
| 1421 | return self.atoms.items[index]; |
| 1422 | } |
| 1423 | |
| 1424 | fn getAtomPtr(self: *Plan9, index: Atom.Index) *Atom { |
| 1425 | return &self.atoms.items[index]; |
| 1426 | } |
Andrew Kelley <andrew@ziglang.org> 2025-08-10 23:55:40-07:00
src