diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Sema.zig | 57 | ||||
| -rw-r--r-- | src/arch/arm/CodeGen.zig | 184 | ||||
| -rw-r--r-- | src/codegen/llvm.zig | 347 | ||||
| -rw-r--r-- | src/crash_report.zig | 2 | ||||
| -rw-r--r-- | src/link.zig | 3 | ||||
| -rw-r--r-- | src/link/MachO/Object.zig | 526 | ||||
| -rw-r--r-- | src/link/MachO/UnwindInfo.zig | 845 | ||||
| -rw-r--r-- | src/link/MachO/ZldAtom.zig | 244 | ||||
| -rw-r--r-- | src/link/MachO/dead_strip.zig | 217 | ||||
| -rw-r--r-- | src/link/MachO/eh_frame.zig | 625 | ||||
| -rw-r--r-- | src/link/MachO/thunks.zig | 9 | ||||
| -rw-r--r-- | src/link/MachO/zld.zig | 227 | ||||
| -rw-r--r-- | src/type.zig | 46 | ||||
| -rw-r--r-- | src/value.zig | 34 |
14 files changed, 2685 insertions, 681 deletions
diff --git a/src/Sema.zig b/src/Sema.zig index dcc38e4c0a..124af6c131 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -3948,6 +3948,7 @@ fn validateArrayInitTy( return; }, .Struct => if (ty.isTuple()) { + _ = try sema.resolveTypeFields(ty); const array_len = ty.arrayLen(); if (extra.init_count > array_len) { return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{ @@ -4642,11 +4643,11 @@ fn failWithBadMemberAccess( .Enum => "enum", else => unreachable, }; - if (sema.mod.declIsRoot(agg_ty.getOwnerDecl())) { + if (agg_ty.getOwnerDeclOrNull()) |some| if (sema.mod.declIsRoot(some)) { return sema.fail(block, field_src, "root struct of file '{}' has no member named '{s}'", .{ agg_ty.fmt(sema.mod), field_name, }); - } + }; const msg = msg: { const msg = try sema.errMsg(block, field_src, "{s} '{}' has no member named '{s}'", .{ kw_name, agg_ty.fmt(sema.mod), field_name, @@ -7514,7 +7515,7 @@ fn resolveGenericInstantiationType( } fn resolveTupleLazyValues(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!void { - if (!ty.isSimpleTuple()) return; + if (!ty.isSimpleTupleOrAnonStruct()) return; const tuple = ty.tupleFields(); for (tuple.values) |field_val, i| { try sema.resolveTupleLazyValues(block, src, tuple.types[i]); @@ -11771,8 +11772,8 @@ fn zirShl( // TODO coerce rhs if air_tag is not shl_sat const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty); - const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs); - const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs); + const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs); + const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs); if (maybe_rhs_val) |rhs_val| { if (rhs_val.isUndef()) { @@ -11842,7 +11843,7 @@ fn zirShl( if (scalar_ty.zigTypeTag() == .ComptimeInt) { break :val shifted.wrapped_result; } - if (shifted.overflow_bit.compareAllWithZero(.eq)) { + if (shifted.overflow_bit.compareAllWithZero(.eq, sema.mod)) { break :val shifted.wrapped_result; } return sema.fail(block, src, "operation caused overflow", .{}); @@ -11959,8 +11960,8 @@ fn zirShr( const target = sema.mod.getTarget(); const scalar_ty = lhs_ty.scalarType(); - const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs); - const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs); + const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs); + const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs); const runtime_src = if (maybe_rhs_val) |rhs_val| rs: { if (rhs_val.isUndef()) { @@ -12799,7 +12800,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -12831,7 +12832,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins const lhs_val = maybe_lhs_val orelse unreachable; const rhs_val = maybe_rhs_val orelse unreachable; const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod) catch unreachable; - if (!rem.compareAllWithZero(.eq)) { + if (!rem.compareAllWithZero(.eq, mod)) { return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{ @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod), }); @@ -12959,7 +12960,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_exact); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -13024,7 +13025,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai if (maybe_rhs_val) |rhs_val| { if (is_int) { const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod); - if (!(modulus_val.compareAllWithZero(.eq))) { + if (!(modulus_val.compareAllWithZero(.eq, mod))) { return sema.fail(block, src, "exact division produced remainder", .{}); } const res = try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, mod); @@ -13035,7 +13036,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai return sema.addConstant(resolved_type, res); } else { const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod); - if (!(modulus_val.compareAllWithZero(.eq))) { + if (!(modulus_val.compareAllWithZero(.eq, mod))) { return sema.fail(block, src, "exact division produced remainder", .{}); } return sema.addConstant( @@ -13122,7 +13123,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_floor); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -13238,7 +13239,7 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .div_trunc); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -13481,7 +13482,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod_rem); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -13664,7 +13665,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -13766,7 +13767,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(); const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); - try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .rem); + try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); const instructions = &[_]Air.Inst.Ref{ lhs, rhs }; const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ @@ -14106,12 +14107,7 @@ fn analyzeArithmetic( const air_tag: Air.Inst.Tag = switch (zir_tag) { .add => .ptr_add, .sub => .ptr_sub, - else => return sema.fail( - block, - src, - "invalid pointer arithmetic operand: '{s}''", - .{@tagName(zir_tag)}, - ), + else => return sema.fail(block, src, "invalid pointer arithmetic operator", .{}), }; return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src); }, @@ -19697,7 +19693,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } } - if (try sema.resolveMaybeUndefVal(operand)) |val| { + if (try sema.resolveMaybeUndefValIntable(operand)) |val| { if (val.isUndef()) return sema.addConstUndef(dest_ty); if (!is_vector) { return sema.addConstant( @@ -19901,7 +19897,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node }; const operand = try sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); - _ = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src); + const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src); if (try sema.typeHasOnePossibleValue(operand_ty)) |val| { return sema.addConstant(operand_ty, val); @@ -19909,7 +19905,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const target = sema.mod.getTarget(); switch (operand_ty.zigTypeTag()) { - .Int, .ComptimeInt => { + .Int => { const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| { if (val.isUndef()) return sema.addConstUndef(operand_ty); const result_val = try val.bitReverse(operand_ty, target, sema.arena); @@ -19929,7 +19925,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const elems = try sema.arena.alloc(Value, vec_len); for (elems) |*elem, i| { const elem_val = val.elemValueBuffer(sema.mod, i, &elem_buf); - elem.* = try elem_val.bitReverse(operand_ty, target, sema.arena); + elem.* = try elem_val.bitReverse(scalar_ty, target, sema.arena); } return sema.addConstant( operand_ty, @@ -20028,7 +20024,6 @@ fn checkInvalidPtrArithmetic( block: *Block, src: LazySrcLoc, ty: Type, - zir_tag: Zir.Inst.Tag, ) CompileError!void { switch (try ty.zigTypeTagOrPoison()) { .Pointer => switch (ty.ptrSize()) { @@ -20036,8 +20031,8 @@ fn checkInvalidPtrArithmetic( .Many, .C => return sema.fail( block, src, - "invalid pointer arithmetic operand: '{s}''", - .{@tagName(zir_tag)}, + "invalid pointer arithmetic operator", + .{}, ), }, else => return, diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig index 73c97fb7e5..fec844a867 100644 --- a/src/arch/arm/CodeGen.zig +++ b/src/arch/arm/CodeGen.zig @@ -77,11 +77,11 @@ end_di_column: u32, /// which is a relative jump, based on the address following the reloc. exitlude_jump_relocs: std.ArrayListUnmanaged(usize) = .{}, -/// For every argument, we postpone the creation of debug info for -/// later after all Mir instructions have been generated. Only then we +/// We postpone the creation of debug info for function args and locals +/// until after all Mir instructions have been generated. Only then we /// will know saved_regs_stack_space which is necessary in order to -/// address parameters passed on the stack. -dbg_arg_relocs: std.ArrayListUnmanaged(DbgArgReloc) = .{}, +/// calculate the right stack offsest with respect to the `.fp` register. +dbg_info_relocs: std.ArrayListUnmanaged(DbgInfoReloc) = .{}, /// Whenever there is a runtime branch, we push a Branch onto this stack, /// and pop it off when the runtime branch joins. This provides an "overlay" @@ -243,9 +243,107 @@ const BigTomb = struct { } }; -const DbgArgReloc = struct { - inst: Air.Inst.Index, - index: u32, +const DbgInfoReloc = struct { + tag: Air.Inst.Tag, + ty: Type, + name: [:0]const u8, + mcv: MCValue, + + fn genDbgInfo(reloc: DbgInfoReloc, function: Self) !void { + switch (reloc.tag) { + .arg => try reloc.genArgDbgInfo(function), + + .dbg_var_ptr, + .dbg_var_val, + => try reloc.genVarDbgInfo(function), + + else => unreachable, + } + } + + fn genArgDbgInfo(reloc: DbgInfoReloc, function: Self) error{OutOfMemory}!void { + switch (function.debug_output) { + .dwarf => |dw| { + const loc: link.File.Dwarf.DeclState.DbgInfoLoc = switch (reloc.mcv) { + .register => |reg| .{ .register = reg.dwarfLocOp() }, + .stack_offset, + .stack_argument_offset, + => blk: { + const adjusted_stack_offset = switch (reloc.mcv) { + .stack_offset => |offset| -@intCast(i32, offset), + .stack_argument_offset => |offset| @intCast(i32, function.saved_regs_stack_space + offset), + else => unreachable, + }; + break :blk .{ .stack = .{ + .fp_register = DW.OP.breg11, + .offset = adjusted_stack_offset, + } }; + }, + else => unreachable, // not a possible argument + }; + + try dw.genArgDbgInfo( + reloc.name, + reloc.ty, + function.bin_file.tag, + function.mod_fn.owner_decl, + loc, + ); + }, + .plan9 => {}, + .none => {}, + } + } + + fn genVarDbgInfo(reloc: DbgInfoReloc, function: Self) !void { + const is_ptr = switch (reloc.tag) { + .dbg_var_ptr => true, + .dbg_var_val => false, + else => unreachable, + }; + + switch (function.debug_output) { + .dwarf => |dw| { + const loc: link.File.Dwarf.DeclState.DbgInfoLoc = switch (reloc.mcv) { + .register => |reg| .{ .register = reg.dwarfLocOp() }, + .ptr_stack_offset, + .stack_offset, + .stack_argument_offset, + => |offset| blk: { + const adjusted_offset = switch (reloc.mcv) { + .ptr_stack_offset, + .stack_offset, + => -@intCast(i32, offset), + .stack_argument_offset => @intCast(i32, function.saved_regs_stack_space + offset), + else => unreachable, + }; + break :blk .{ .stack = .{ + .fp_register = DW.OP.breg11, + .offset = adjusted_offset, + } }; + }, + .memory => |address| .{ .memory = address }, + .immediate => |x| .{ .immediate = x }, + .undef => .undef, + .none => .none, + else => blk: { + log.debug("TODO generate debug info for {}", .{reloc.mcv}); + break :blk .nop; + }, + }; + try dw.genVarDbgInfo( + reloc.name, + reloc.ty, + function.bin_file.tag, + function.mod_fn.owner_decl, + is_ptr, + loc, + ); + }, + .plan9 => {}, + .none => {}, + } + } }; const Self = @This(); @@ -298,7 +396,7 @@ pub fn generate( defer function.stack.deinit(bin_file.allocator); defer function.blocks.deinit(bin_file.allocator); defer function.exitlude_jump_relocs.deinit(bin_file.allocator); - defer function.dbg_arg_relocs.deinit(bin_file.allocator); + defer function.dbg_info_relocs.deinit(bin_file.allocator); var call_info = function.resolveCallingConventionValues(fn_type) catch |err| switch (err) { error.CodegenFail => return FnResult{ .fail = function.err_msg.? }, @@ -322,8 +420,8 @@ pub fn generate( else => |e| return e, }; - for (function.dbg_arg_relocs.items) |reloc| { - try function.genArgDbgInfo(reloc.inst, reloc.index); + for (function.dbg_info_relocs.items) |reloc| { + try reloc.genDbgInfo(function); } var mir = Mir{ @@ -896,9 +994,6 @@ fn allocMem( assert(abi_size > 0); assert(abi_align > 0); - if (abi_align > self.stack_align) - self.stack_align = abi_align; - // TODO find a free slot instead of always appending const offset = mem.alignForwardGeneric(u32, self.next_stack_offset, abi_align) + abi_size; self.next_stack_offset = offset; @@ -4035,46 +4130,20 @@ fn genInlineMemsetCode( // end: } -fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, arg_index: u32) error{OutOfMemory}!void { - const mcv = self.args[arg_index]; - const arg = self.air.instructions.items(.data)[inst].arg; - const ty = self.air.getRefType(arg.ty); - const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg.src_index); - - switch (self.debug_output) { - .dwarf => |dw| { - const loc: link.File.Dwarf.DeclState.DbgInfoLoc = switch (mcv) { - .register => |reg| .{ .register = reg.dwarfLocOp() }, - .stack_offset, - .stack_argument_offset, - => blk: { - const adjusted_stack_offset = switch (mcv) { - .stack_offset => |offset| -@intCast(i32, offset), - .stack_argument_offset => |offset| @intCast(i32, self.saved_regs_stack_space + offset), - else => unreachable, - }; - break :blk .{ .stack = .{ - .fp_register = DW.OP.breg11, - .offset = adjusted_stack_offset, - } }; - }, - else => unreachable, // not a possible argument - - }; - try dw.genArgDbgInfo(name, ty, self.bin_file.tag, self.mod_fn.owner_decl, loc); - }, - .plan9 => {}, - .none => {}, - } -} - fn airArg(self: *Self, inst: Air.Inst.Index) !void { const arg_index = self.arg_index; self.arg_index += 1; - try self.dbg_arg_relocs.append(self.gpa, .{ - .inst = inst, - .index = arg_index, + const ty = self.air.typeOfIndex(inst); + const tag = self.air.instructions.items(.tag)[inst]; + const src_index = self.air.instructions.items(.data)[inst].arg.src_index; + const name = self.mod_fn.getParamName(self.bin_file.options.module.?, src_index); + + try self.dbg_info_relocs.append(self.gpa, .{ + .tag = tag, + .ty = ty, + .name = name, + .mcv = self.args[arg_index], }); const result: MCValue = if (self.liveness.isUnused(inst)) .dead else self.args[arg_index]; @@ -4485,10 +4554,21 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void { fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void { const pl_op = self.air.instructions.items(.data)[inst].pl_op; - const name = self.air.nullTerminatedString(pl_op.payload); const operand = pl_op.operand; - // TODO emit debug info for this variable - _ = name; + const tag = self.air.instructions.items(.tag)[inst]; + const ty = self.air.typeOf(operand); + const mcv = try self.resolveInst(operand); + const name = self.air.nullTerminatedString(pl_op.payload); + + log.debug("airDbgVar: %{d}: {}, {}", .{ inst, ty.fmtDebug(), mcv }); + + try self.dbg_info_relocs.append(self.gpa, .{ + .tag = tag, + .ty = ty, + .name = name, + .mcv = mcv, + }); + return self.finishAir(inst, .dead, .{ operand, .none, .none }); } diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 3d31661b1e..c528abdd7c 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -10396,12 +10396,7 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool .mips, .mipsel => return false, .x86_64 => switch (target.os.tag) { .windows => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory, - else => { - const class = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret); - if (class[0] == .memory) return true; - if (class[0] == .x87 and class[2] != .none) return true; - return false; - }, + else => return firstParamSRetSystemV(fn_info.return_type, target), }, .wasm32 => return wasm_c_abi.classifyType(fn_info.return_type, target)[0] == .indirect, .aarch64, .aarch64_be => return aarch64_c_abi.classifyType(fn_info.return_type, target) == .memory, @@ -10413,11 +10408,20 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool .riscv32, .riscv64 => return riscv_c_abi.classifyType(fn_info.return_type, target) == .memory, else => return false, // TODO investigate C ABI for other architectures }, + .SysV => return firstParamSRetSystemV(fn_info.return_type, target), + .Win64 => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory, .Stdcall => return !isScalar(fn_info.return_type), else => return false, } } +fn firstParamSRetSystemV(ty: Type, target: std.Target) bool { + const class = x86_64_abi.classifySystemV(ty, target, .ret); + if (class[0] == .memory) return true; + if (class[0] == .x87 and class[2] != .none) return true; + return false; +} + /// In order to support the C calling convention, some return types need to be lowered /// completely differently in the function prototype to honor the C ABI, and then /// be effectively bitcasted to the actual return type. @@ -10442,77 +10446,14 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type { } }, .C => { - const is_scalar = isScalar(fn_info.return_type); switch (target.cpu.arch) { .mips, .mipsel => return dg.lowerType(fn_info.return_type), .x86_64 => switch (target.os.tag) { - .windows => switch (x86_64_abi.classifyWindows(fn_info.return_type, target)) { - .integer => { - if (is_scalar) { - return dg.lowerType(fn_info.return_type); - } else { - const abi_size = fn_info.return_type.abiSize(target); - return dg.context.intType(@intCast(c_uint, abi_size * 8)); - } - }, - .win_i128 => return dg.context.intType(64).vectorType(2), - .memory => return dg.context.voidType(), - .sse => return dg.lowerType(fn_info.return_type), - else => unreachable, - }, - else => { - if (is_scalar) { - return dg.lowerType(fn_info.return_type); - } - const classes = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret); - if (classes[0] == .memory) { - return dg.context.voidType(); - } - var llvm_types_buffer: [8]*llvm.Type = undefined; - var llvm_types_index: u32 = 0; - for (classes) |class| { - switch (class) { - .integer => { - llvm_types_buffer[llvm_types_index] = dg.context.intType(64); - llvm_types_index += 1; - }, - .sse, .sseup => { - llvm_types_buffer[llvm_types_index] = dg.context.doubleType(); - llvm_types_index += 1; - }, - .float => { - llvm_types_buffer[llvm_types_index] = dg.context.floatType(); - llvm_types_index += 1; - }, - .float_combine => { - llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2); - llvm_types_index += 1; - }, - .x87 => { - if (llvm_types_index != 0 or classes[2] != .none) { - return dg.context.voidType(); - } - llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type(); - llvm_types_index += 1; - }, - .x87up => continue, - .complex_x87 => { - @panic("TODO"); - }, - .memory => unreachable, // handled above - .win_i128 => unreachable, // windows only - .none => break, - } - } - if (classes[0] == .integer and classes[1] == .none) { - const abi_size = fn_info.return_type.abiSize(target); - return dg.context.intType(@intCast(c_uint, abi_size * 8)); - } - return dg.context.structType(&llvm_types_buffer, llvm_types_index, .False); - }, + .windows => return lowerWin64FnRetTy(dg, fn_info), + else => return lowerSystemVFnRetTy(dg, fn_info), }, .wasm32 => { - if (is_scalar) { + if (isScalar(fn_info.return_type)) { return dg.lowerType(fn_info.return_type); } const classes = wasm_c_abi.classifyType(fn_info.return_type, target); @@ -10569,6 +10510,8 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type { else => return dg.lowerType(fn_info.return_type), } }, + .Win64 => return lowerWin64FnRetTy(dg, fn_info), + .SysV => return lowerSystemVFnRetTy(dg, fn_info), .Stdcall => { if (isScalar(fn_info.return_type)) { return dg.lowerType(fn_info.return_type); @@ -10580,6 +10523,76 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type { } } +fn lowerWin64FnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type { + const target = dg.module.getTarget(); + switch (x86_64_abi.classifyWindows(fn_info.return_type, target)) { + .integer => { + if (isScalar(fn_info.return_type)) { + return dg.lowerType(fn_info.return_type); + } else { + const abi_size = fn_info.return_type.abiSize(target); + return dg.context.intType(@intCast(c_uint, abi_size * 8)); + } + }, + .win_i128 => return dg.context.intType(64).vectorType(2), + .memory => return dg.context.voidType(), + .sse => return dg.lowerType(fn_info.return_type), + else => unreachable, + } +} + +fn lowerSystemVFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type { + if (isScalar(fn_info.return_type)) { + return dg.lowerType(fn_info.return_type); + } + const target = dg.module.getTarget(); + const classes = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret); + if (classes[0] == .memory) { + return dg.context.voidType(); + } + var llvm_types_buffer: [8]*llvm.Type = undefined; + var llvm_types_index: u32 = 0; + for (classes) |class| { + switch (class) { + .integer => { + llvm_types_buffer[llvm_types_index] = dg.context.intType(64); + llvm_types_index += 1; + }, + .sse, .sseup => { + llvm_types_buffer[llvm_types_index] = dg.context.doubleType(); + llvm_types_index += 1; + }, + .float => { + llvm_types_buffer[llvm_types_index] = dg.context.floatType(); + llvm_types_index += 1; + }, + .float_combine => { + llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2); + llvm_types_index += 1; + }, + .x87 => { + if (llvm_types_index != 0 or classes[2] != .none) { + return dg.context.voidType(); + } + llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type(); + llvm_types_index += 1; + }, + .x87up => continue, + .complex_x87 => { + @panic("TODO"); + }, + .memory => unreachable, // handled above + .win_i128 => unreachable, // windows only + .none => break, + } + } + if (classes[0] == .integer and classes[1] == .none) { + const abi_size = fn_info.return_type.abiSize(target); + return dg.context.intType(@intCast(c_uint, abi_size * 8)); + } + return dg.context.structType(&llvm_types_buffer, llvm_types_index, .False); +} + const ParamTypeIterator = struct { dg: *DeclGen, fn_info: Type.Payload.Function.Data, @@ -10629,7 +10642,6 @@ const ParamTypeIterator = struct { it.zig_index += 1; return .no_bits; } - const dg = it.dg; switch (it.fn_info.cc) { .Unspecified, .Inline => { it.zig_index += 1; @@ -10648,7 +10660,6 @@ const ParamTypeIterator = struct { @panic("TODO implement async function lowering in the LLVM backend"); }, .C => { - const is_scalar = isScalar(ty); switch (it.target.cpu.arch) { .mips, .mipsel => { it.zig_index += 1; @@ -10656,99 +10667,13 @@ const ParamTypeIterator = struct { return .byval; }, .x86_64 => switch (it.target.os.tag) { - .windows => switch (x86_64_abi.classifyWindows(ty, it.target)) { - .integer => { - if (is_scalar) { - it.zig_index += 1; - it.llvm_index += 1; - return .byval; - } else { - it.zig_index += 1; - it.llvm_index += 1; - return .abi_sized_int; - } - }, - .win_i128 => { - it.zig_index += 1; - it.llvm_index += 1; - return .byref; - }, - .memory => { - it.zig_index += 1; - it.llvm_index += 1; - return .byref_mut; - }, - .sse => { - it.zig_index += 1; - it.llvm_index += 1; - return .byval; - }, - else => unreachable, - }, - else => { - const classes = x86_64_abi.classifySystemV(ty, it.target, .arg); - if (classes[0] == .memory) { - it.zig_index += 1; - it.llvm_index += 1; - it.byval_attr = true; - return .byref; - } - if (is_scalar) { - it.zig_index += 1; - it.llvm_index += 1; - return .byval; - } - var llvm_types_buffer: [8]*llvm.Type = undefined; - var llvm_types_index: u32 = 0; - for (classes) |class| { - switch (class) { - .integer => { - llvm_types_buffer[llvm_types_index] = dg.context.intType(64); - llvm_types_index += 1; - }, - .sse, .sseup => { - llvm_types_buffer[llvm_types_index] = dg.context.doubleType(); - llvm_types_index += 1; - }, - .float => { - llvm_types_buffer[llvm_types_index] = dg.context.floatType(); - llvm_types_index += 1; - }, - .float_combine => { - llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2); - llvm_types_index += 1; - }, - .x87 => { - it.zig_index += 1; - it.llvm_index += 1; - it.byval_attr = true; - return .byref; - }, - .x87up => unreachable, - .complex_x87 => { - @panic("TODO"); - }, - .memory => unreachable, // handled above - .win_i128 => unreachable, // windows only - .none => break, - } - } - if (classes[0] == .integer and classes[1] == .none) { - it.zig_index += 1; - it.llvm_index += 1; - return .abi_sized_int; - } - it.llvm_types_buffer = llvm_types_buffer; - it.llvm_types_len = llvm_types_index; - it.llvm_index += llvm_types_index; - it.zig_index += 1; - return .multiple_llvm_types; - }, + .windows => return it.nextWin64(ty), + else => return it.nextSystemV(ty), }, .wasm32 => { it.zig_index += 1; it.llvm_index += 1; - if (is_scalar) { + if (isScalar(ty)) { return .byval; } const classes = wasm_c_abi.classifyType(ty, it.target); @@ -10766,7 +10691,7 @@ const ParamTypeIterator = struct { .byval => return .byval, .integer => { it.llvm_types_len = 1; - it.llvm_types_buffer[0] = dg.context.intType(64); + it.llvm_types_buffer[0] = it.dg.context.intType(64); return .multiple_llvm_types; }, .double_integer => return Lowering{ .i64_array = 2 }, @@ -10806,6 +10731,8 @@ const ParamTypeIterator = struct { }, } }, + .Win64 => return it.nextWin64(ty), + .SysV => return it.nextSystemV(ty), .Stdcall => { it.zig_index += 1; it.llvm_index += 1; @@ -10824,6 +10751,98 @@ const ParamTypeIterator = struct { }, } } + + fn nextWin64(it: *ParamTypeIterator, ty: Type) ?Lowering { + switch (x86_64_abi.classifyWindows(ty, it.target)) { + .integer => { + if (isScalar(ty)) { + it.zig_index += 1; + it.llvm_index += 1; + return .byval; + } else { + it.zig_index += 1; + it.llvm_index += 1; + return .abi_sized_int; + } + }, + .win_i128 => { + it.zig_index += 1; + it.llvm_index += 1; + return .byref; + }, + .memory => { + it.zig_index += 1; + it.llvm_index += 1; + return .byref_mut; + }, + .sse => { + it.zig_index += 1; + it.llvm_index += 1; + return .byval; + }, + else => unreachable, + } + } + + fn nextSystemV(it: *ParamTypeIterator, ty: Type) ?Lowering { + const classes = x86_64_abi.classifySystemV(ty, it.target, .arg); + if (classes[0] == .memory) { + it.zig_index += 1; + it.llvm_index += 1; + it.byval_attr = true; + return .byref; + } + if (isScalar(ty)) { + it.zig_index += 1; + it.llvm_index += 1; + return .byval; + } + var llvm_types_buffer: [8]*llvm.Type = undefined; + var llvm_types_index: u32 = 0; + for (classes) |class| { + switch (class) { + .integer => { + llvm_types_buffer[llvm_types_index] = it.dg.context.intType(64); + llvm_types_index += 1; + }, + .sse, .sseup => { + llvm_types_buffer[llvm_types_index] = it.dg.context.doubleType(); + llvm_types_index += 1; + }, + .float => { + llvm_types_buffer[llvm_types_index] = it.dg.context.floatType(); + llvm_types_index += 1; + }, + .float_combine => { + llvm_types_buffer[llvm_types_index] = it.dg.context.floatType().vectorType(2); + llvm_types_index += 1; + }, + .x87 => { + it.zig_index += 1; + it.llvm_index += 1; + it.byval_attr = true; + return .byref; + }, + .x87up => unreachable, + .complex_x87 => { + @panic("TODO"); + }, + .memory => unreachable, // handled above + .win_i128 => unreachable, // windows only + .none => break, + } + } + if (classes[0] == .integer and classes[1] == .none) { + it.zig_index += 1; + it.llvm_index += 1; + return .abi_sized_int; + } + it.llvm_types_buffer = llvm_types_buffer; + it.llvm_types_len = llvm_types_index; + it.llvm_index += llvm_types_index; + it.zig_index += 1; + return .multiple_llvm_types; + } }; fn iterateParamTypes(dg: *DeclGen, fn_info: Type.Payload.Function.Data) ParamTypeIterator { diff --git a/src/crash_report.zig b/src/crash_report.zig index 1bc0dd7626..b2e3018de6 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -238,12 +238,14 @@ fn handleSegfaultPosix(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const any const ip = switch (native_os) { .macos => @intCast(usize, ctx.mcontext.ss.pc), .netbsd => @intCast(usize, ctx.mcontext.gregs[os.REG.PC]), + .freebsd => @intCast(usize, ctx.mcontext.gpregs.elr), else => @intCast(usize, ctx.mcontext.pc), }; // x29 is the ABI-designated frame pointer const bp = switch (native_os) { .macos => @intCast(usize, ctx.mcontext.ss.fp), .netbsd => @intCast(usize, ctx.mcontext.gregs[os.REG.FP]), + .freebsd => @intCast(usize, ctx.mcontext.gpregs.x[os.REG.FP]), else => @intCast(usize, ctx.mcontext.regs[29]), }; break :ctx StackContext{ .exception = .{ .bp = bp, .ip = ip } }; diff --git a/src/link.zig b/src/link.zig index 2fb85cb482..2317525827 100644 --- a/src/link.zig +++ b/src/link.zig @@ -697,6 +697,7 @@ pub const File = struct { /// TODO audit this error set. most of these should be collapsed into one error, /// and ErrorFlags should be updated to convey the meaning to the user. pub const FlushError = error{ + BadDwarfCfi, CacheUnavailable, CurrentWorkingDirectoryUnlinked, DivisionByZero, @@ -737,6 +738,8 @@ pub const File = struct { MissingEndForExpression, /// TODO: this should be removed from the error set in favor of using ErrorFlags MissingMainEntrypoint, + /// TODO: this should be removed from the error set in favor of using ErrorFlags + MissingSection, MissingSymbol, MissingTableSymbols, ModuleNameMismatch, diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig index 401184da51..13219084b6 100644 --- a/src/link/MachO/Object.zig +++ b/src/link/MachO/Object.zig @@ -8,6 +8,7 @@ const std = @import("std"); const build_options = @import("build_options"); const assert = std.debug.assert; const dwarf = std.dwarf; +const eh_frame = @import("eh_frame.zig"); const fs = std.fs; const io = std.io; const log = std.log.scoped(.link); @@ -24,6 +25,7 @@ const DwarfInfo = @import("DwarfInfo.zig"); const LoadCommandIterator = macho.LoadCommandIterator; const Zld = @import("zld.zig").Zld; const SymbolWithLoc = @import("zld.zig").SymbolWithLoc; +const UnwindInfo = @import("UnwindInfo.zig"); name: []const u8, mtime: u64, @@ -44,6 +46,8 @@ symtab: []macho.nlist_64 = undefined, /// Can be undefined as set together with in_symtab. source_symtab_lookup: []u32 = undefined, /// Can be undefined as set together with in_symtab. +reverse_symtab_lookup: []u32 = undefined, +/// Can be undefined as set together with in_symtab. source_address_lookup: []i64 = undefined, /// Can be undefined as set together with in_symtab. source_section_index_lookup: []i64 = undefined, @@ -53,22 +57,49 @@ strtab_lookup: []u32 = undefined, atom_by_index_table: []AtomIndex = undefined, /// Can be undefined as set together with in_symtab. globals_lookup: []i64 = undefined, +/// Can be undefined as set together with in_symtab. +relocs_lookup: []RelocEntry = undefined, atoms: std.ArrayListUnmanaged(AtomIndex) = .{}, +exec_atoms: std.ArrayListUnmanaged(AtomIndex) = .{}, + +eh_frame_sect: ?macho.section_64 = null, +eh_frame_relocs_lookup: std.AutoArrayHashMapUnmanaged(u32, Record) = .{}, +eh_frame_records_lookup: std.AutoArrayHashMapUnmanaged(AtomIndex, u32) = .{}, + +unwind_info_sect: ?macho.section_64 = null, +unwind_relocs_lookup: []Record = undefined, +unwind_records_lookup: std.AutoHashMapUnmanaged(AtomIndex, u32) = .{}, + +const RelocEntry = struct { start: u32, len: u32 }; + +const Record = struct { + dead: bool, + reloc: RelocEntry, +}; pub fn deinit(self: *Object, gpa: Allocator) void { self.atoms.deinit(gpa); + self.exec_atoms.deinit(gpa); gpa.free(self.name); gpa.free(self.contents); if (self.in_symtab) |_| { gpa.free(self.source_symtab_lookup); + gpa.free(self.reverse_symtab_lookup); gpa.free(self.source_address_lookup); gpa.free(self.source_section_index_lookup); gpa.free(self.strtab_lookup); gpa.free(self.symtab); gpa.free(self.atom_by_index_table); gpa.free(self.globals_lookup); + gpa.free(self.relocs_lookup); } + self.eh_frame_relocs_lookup.deinit(gpa); + self.eh_frame_records_lookup.deinit(gpa); + if (self.hasUnwindRecords()) { + gpa.free(self.unwind_relocs_lookup); + } + self.unwind_records_lookup.deinit(gpa); } pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch) !void { @@ -105,76 +136,95 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch) .ncmds = self.header.ncmds, .buffer = self.contents[@sizeOf(macho.mach_header_64)..][0..self.header.sizeofcmds], }; - while (it.next()) |cmd| { - switch (cmd.cmd()) { - .SYMTAB => { - const symtab = cmd.cast(macho.symtab_command).?; - self.in_symtab = @ptrCast( - [*]const macho.nlist_64, - @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]), - )[0..symtab.nsyms]; - self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize]; - - const nsects = self.getSourceSections().len; - - self.symtab = try allocator.alloc(macho.nlist_64, self.in_symtab.?.len + nsects); - self.source_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len); - self.strtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len); - self.globals_lookup = try allocator.alloc(i64, self.in_symtab.?.len); - self.atom_by_index_table = try allocator.alloc(AtomIndex, self.in_symtab.?.len + nsects); - // This is wasteful but we need to be able to lookup source symbol address after stripping and - // allocating of sections. - self.source_address_lookup = try allocator.alloc(i64, self.in_symtab.?.len); - self.source_section_index_lookup = try allocator.alloc(i64, nsects); - - for (self.symtab) |*sym| { - sym.* = .{ - .n_value = 0, - .n_sect = 0, - .n_desc = 0, - .n_strx = 0, - .n_type = 0, - }; - } + const nsects = self.getSourceSections().len; + const symtab = while (it.next()) |cmd| switch (cmd.cmd()) { + .SYMTAB => break cmd.cast(macho.symtab_command).?, + else => {}, + } else return; + + self.in_symtab = @ptrCast( + [*]const macho.nlist_64, + @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]), + )[0..symtab.nsyms]; + self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize]; + + self.symtab = try allocator.alloc(macho.nlist_64, self.in_symtab.?.len + nsects); + self.source_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len); + self.reverse_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len); + self.strtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len); + self.globals_lookup = try allocator.alloc(i64, self.in_symtab.?.len); + self.atom_by_index_table = try allocator.alloc(AtomIndex, self.in_symtab.?.len + nsects); + self.relocs_lookup = try allocator.alloc(RelocEntry, self.in_symtab.?.len + nsects); + // This is wasteful but we need to be able to lookup source symbol address after stripping and + // allocating of sections. + self.source_address_lookup = try allocator.alloc(i64, self.in_symtab.?.len); + self.source_section_index_lookup = try allocator.alloc(i64, nsects); + + for (self.symtab) |*sym| { + sym.* = .{ + .n_value = 0, + .n_sect = 0, + .n_desc = 0, + .n_strx = 0, + .n_type = 0, + }; + } - mem.set(i64, self.globals_lookup, -1); - mem.set(AtomIndex, self.atom_by_index_table, 0); - mem.set(i64, self.source_section_index_lookup, -1); + mem.set(i64, self.globals_lookup, -1); + mem.set(AtomIndex, self.atom_by_index_table, 0); + mem.set(i64, self.source_section_index_lookup, -1); + mem.set(RelocEntry, self.relocs_lookup, .{ + .start = 0, + .len = 0, + }); - // You would expect that the symbol table is at least pre-sorted based on symbol's type: - // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance, - // the GO compiler does not necessarily respect that therefore we sort immediately by type - // and address within. - var sorted_all_syms = try std.ArrayList(SymbolAtIndex).initCapacity(allocator, self.in_symtab.?.len); - defer sorted_all_syms.deinit(); + // You would expect that the symbol table is at least pre-sorted based on symbol's type: + // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance, + // the GO compiler does not necessarily respect that therefore we sort immediately by type + // and address within. + var sorted_all_syms = try std.ArrayList(SymbolAtIndex).initCapacity(allocator, self.in_symtab.?.len); + defer sorted_all_syms.deinit(); - for (self.in_symtab.?) |_, index| { - sorted_all_syms.appendAssumeCapacity(.{ .index = @intCast(u32, index) }); - } + for (self.in_symtab.?) |_, index| { + sorted_all_syms.appendAssumeCapacity(.{ .index = @intCast(u32, index) }); + } - // We sort by type: defined < undefined, and - // afterwards by address in each group. Normally, dysymtab should - // be enough to guarantee the sort, but turns out not every compiler - // is kind enough to specify the symbols in the correct order. - sort.sort(SymbolAtIndex, sorted_all_syms.items, self, SymbolAtIndex.lessThan); + // We sort by type: defined < undefined, and + // afterwards by address in each group. Normally, dysymtab should + // be enough to guarantee the sort, but turns out not every compiler + // is kind enough to specify the symbols in the correct order. + sort.sort(SymbolAtIndex, sorted_all_syms.items, self, SymbolAtIndex.lessThan); - for (sorted_all_syms.items) |sym_id, i| { - const sym = sym_id.getSymbol(self); + for (sorted_all_syms.items) |sym_id, i| { + const sym = sym_id.getSymbol(self); - if (sym.sect() and self.source_section_index_lookup[sym.n_sect - 1] == -1) { - self.source_section_index_lookup[sym.n_sect - 1] = @intCast(i64, i); - } + if (sym.sect() and self.source_section_index_lookup[sym.n_sect - 1] == -1) { + self.source_section_index_lookup[sym.n_sect - 1] = @intCast(i64, i); + } - self.symtab[i] = sym; - self.source_symtab_lookup[i] = sym_id.index; - self.source_address_lookup[i] = if (sym.undf()) -1 else @intCast(i64, sym.n_value); + self.symtab[i] = sym; + self.source_symtab_lookup[i] = sym_id.index; + self.reverse_symtab_lookup[sym_id.index] = @intCast(u32, i); + self.source_address_lookup[i] = if (sym.undf()) -1 else @intCast(i64, sym.n_value); - const sym_name_len = mem.sliceTo(@ptrCast([*:0]const u8, self.in_strtab.?.ptr + sym.n_strx), 0).len + 1; - self.strtab_lookup[i] = @intCast(u32, sym_name_len); - } + const sym_name_len = mem.sliceTo(@ptrCast([*:0]const u8, self.in_strtab.?.ptr + sym.n_strx), 0).len + 1; + self.strtab_lookup[i] = @intCast(u32, sym_name_len); + } + + // Parse __TEXT,__eh_frame header if one exists + self.eh_frame_sect = self.getSourceSectionByName("__TEXT", "__eh_frame"); + + // Parse __LD,__compact_unwind header if one exists + self.unwind_info_sect = self.getSourceSectionByName("__LD", "__compact_unwind"); + if (self.hasUnwindRecords()) { + self.unwind_relocs_lookup = try allocator.alloc(Record, self.getUnwindRecords().len); + mem.set(Record, self.unwind_relocs_lookup, .{ + .dead = true, + .reloc = .{ + .start = 0, + .len = 0, }, - else => {}, - } + }); } } @@ -192,6 +242,17 @@ const SymbolAtIndex = struct { return mem.sliceTo(@ptrCast([*:0]const u8, ctx.in_strtab.?.ptr + off), 0); } + fn getSymbolSeniority(self: SymbolAtIndex, ctx: Context) u2 { + const sym = self.getSymbol(ctx); + if (!sym.ext()) { + const sym_name = self.getSymbolName(ctx); + if (mem.startsWith(u8, sym_name, "l") or mem.startsWith(u8, sym_name, "L")) return 0; + return 1; + } + if (sym.weakDef() or sym.pext()) return 2; + return 3; + } + /// Performs lexicographic-like check. /// * lhs and rhs defined /// * if lhs == rhs @@ -206,23 +267,15 @@ const SymbolAtIndex = struct { if (lhs.sect() and rhs.sect()) { if (lhs.n_value == rhs.n_value) { if (lhs.n_sect == rhs.n_sect) { - if (lhs.ext() and rhs.ext()) { - if ((lhs.pext() or lhs.weakDef()) and (rhs.pext() or rhs.weakDef())) { - return false; - } else return rhs.pext() or rhs.weakDef(); - } else { - const lhs_name = lhs_index.getSymbolName(ctx); - const lhs_temp = mem.startsWith(u8, lhs_name, "l") or mem.startsWith(u8, lhs_name, "L"); - const rhs_name = rhs_index.getSymbolName(ctx); - const rhs_temp = mem.startsWith(u8, rhs_name, "l") or mem.startsWith(u8, rhs_name, "L"); - if (lhs_temp and rhs_temp) { - return false; - } else return rhs_temp; - } + const lhs_senior = lhs_index.getSymbolSeniority(ctx); + const rhs_senior = rhs_index.getSymbolSeniority(ctx); + if (lhs_senior == rhs_senior) { + return lessThanByNStrx(ctx, lhs_index, rhs_index); + } else return lhs_senior < rhs_senior; } else return lhs.n_sect < rhs.n_sect; } else return lhs.n_value < rhs.n_value; } else if (lhs.undf() and rhs.undf()) { - return false; + return lessThanByNStrx(ctx, lhs_index, rhs_index); } else return rhs.undf(); } @@ -295,14 +348,20 @@ fn sectionLessThanByAddress(ctx: void, lhs: SortedSection, rhs: SortedSection) b return lhs.header.addr < rhs.header.addr; } -/// Splits input sections into Atoms. +pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u32) !void { + log.debug("splitting object({d}, {s}) into atoms", .{ object_id, self.name }); + + try self.splitRegularSections(zld, object_id); + try self.parseEhFrameSection(zld, object_id); + try self.parseUnwindInfo(zld, object_id); +} + +/// Splits input regular sections into Atoms. /// If the Object was compiled with `MH_SUBSECTIONS_VIA_SYMBOLS`, splits section /// into subsections where each subsection then represents an Atom. -pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { +pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void { const gpa = zld.gpa; - log.debug("splitting object({d}, {s}) into atoms", .{ object_id, self.name }); - const sections = self.getSourceSections(); for (sections) |sect, id| { if (sect.isDebug()) continue; @@ -418,6 +477,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { sect.@"align", out_sect_id, ); + if (!sect.isZerofill()) { + try self.cacheRelocs(zld, atom_index); + } zld.addAtomToSection(atom_index); } @@ -431,7 +493,6 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { const nsyms_trailing = atom_loc.len - 1; next_sym_index += atom_loc.len; - // TODO: We want to bubble up the first externally defined symbol here. const atom_size = if (next_sym_index < sect_start_index + sect_loc.len) symtab[next_sym_index].n_value - addr else @@ -461,7 +522,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { const alias_index = self.getSectionAliasSymbolIndex(sect_id); self.atom_by_index_table[alias_index] = atom_index; } - + if (!sect.isZerofill()) { + try self.cacheRelocs(zld, atom_index); + } zld.addAtomToSection(atom_index); } } else { @@ -476,6 +539,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { sect.@"align", out_sect_id, ); + if (!sect.isZerofill()) { + try self.cacheRelocs(zld, atom_index); + } zld.addAtomToSection(atom_index); } } @@ -484,7 +550,7 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void { fn createAtomFromSubsection( self: *Object, zld: *Zld, - object_id: u31, + object_id: u32, sym_index: u32, inner_sym_index: u32, inner_nsyms_trailing: u32, @@ -497,7 +563,7 @@ fn createAtomFromSubsection( const atom = zld.getAtomPtr(atom_index); atom.inner_sym_index = inner_sym_index; atom.inner_nsyms_trailing = inner_nsyms_trailing; - atom.file = object_id; + atom.file = object_id + 1; self.symtab[sym_index].n_sect = out_sect_id + 1; log.debug("creating ATOM(%{d}, '{s}') in sect({d}, '{s},{s}') in object({d})", .{ @@ -519,9 +585,220 @@ fn createAtomFromSubsection( self.atom_by_index_table[sym_loc.sym_index] = atom_index; } + const out_sect = zld.sections.items(.header)[out_sect_id]; + if (out_sect.isCode() and + mem.eql(u8, "__TEXT", out_sect.segName()) and + mem.eql(u8, "__text", out_sect.sectName())) + { + // TODO currently assuming a single section for executable machine code + try self.exec_atoms.append(gpa, atom_index); + } + return atom_index; } +fn filterRelocs( + relocs: []align(1) const macho.relocation_info, + start_addr: u64, + end_addr: u64, +) RelocEntry { + const Predicate = struct { + addr: u64, + + pub fn predicate(self: @This(), rel: macho.relocation_info) bool { + return rel.r_address >= self.addr; + } + }; + const LPredicate = struct { + addr: u64, + + pub fn predicate(self: @This(), rel: macho.relocation_info) bool { + return rel.r_address < self.addr; + } + }; + + const start = @import("zld.zig").bsearch(macho.relocation_info, relocs, Predicate{ .addr = end_addr }); + const len = @import("zld.zig").lsearch(macho.relocation_info, relocs[start..], LPredicate{ .addr = start_addr }); + + return .{ .start = @intCast(u32, start), .len = @intCast(u32, len) }; +} + +fn cacheRelocs(self: *Object, zld: *Zld, atom_index: AtomIndex) !void { + const atom = zld.getAtom(atom_index); + + const source_sect = if (self.getSourceSymbol(atom.sym_index)) |source_sym| blk: { + const source_sect = self.getSourceSection(source_sym.n_sect - 1); + assert(!source_sect.isZerofill()); + break :blk source_sect; + } else blk: { + // If there was no matching symbol present in the source symtab, this means + // we are dealing with either an entire section, or part of it, but also + // starting at the beginning. + const nbase = @intCast(u32, self.in_symtab.?.len); + const sect_id = @intCast(u16, atom.sym_index - nbase); + const source_sect = self.getSourceSection(sect_id); + assert(!source_sect.isZerofill()); + break :blk source_sect; + }; + + const relocs = self.getRelocs(source_sect); + + self.relocs_lookup[atom.sym_index] = if (self.getSourceSymbol(atom.sym_index)) |source_sym| blk: { + const offset = source_sym.n_value - source_sect.addr; + break :blk filterRelocs(relocs, offset, offset + atom.size); + } else filterRelocs(relocs, 0, atom.size); +} + +fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void { + const sect = self.eh_frame_sect orelse return; + + log.debug("parsing __TEXT,__eh_frame section", .{}); + + if (zld.getSectionByName("__TEXT", "__eh_frame") == null) { + _ = try zld.initSection("__TEXT", "__eh_frame", .{}); + } + + const gpa = zld.gpa; + const cpu_arch = zld.options.target.cpu.arch; + const relocs = self.getRelocs(sect); + + var it = self.getEhFrameRecordsIterator(); + var record_count: u32 = 0; + while (try it.next()) |_| { + record_count += 1; + } + + try self.eh_frame_relocs_lookup.ensureTotalCapacity(gpa, record_count); + try self.eh_frame_records_lookup.ensureTotalCapacity(gpa, record_count); + + it.reset(); + + while (try it.next()) |record| { + const offset = it.pos - record.getSize(); + const rel_pos = switch (cpu_arch) { + .aarch64 => filterRelocs(relocs, offset, offset + record.getSize()), + .x86_64 => RelocEntry{ .start = 0, .len = 0 }, + else => unreachable, + }; + self.eh_frame_relocs_lookup.putAssumeCapacityNoClobber(offset, .{ + .dead = false, + .reloc = rel_pos, + }); + + if (record.tag == .fde) { + const target = blk: { + switch (cpu_arch) { + .aarch64 => { + assert(rel_pos.len > 0); // TODO convert to an error as the FDE eh frame is malformed + // Find function symbol that this record describes + const rel = relocs[rel_pos.start..][rel_pos.len - 1]; + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + it.data[offset..], + @intCast(i32, offset), + ); + break :blk target; + }, + .x86_64 => { + const target_address = record.getTargetSymbolAddress(.{ + .base_addr = sect.addr, + .base_offset = offset, + }); + const target_sym_index = self.getSymbolByAddress(target_address, null); + const target = if (self.getGlobal(target_sym_index)) |global_index| + zld.globals.items[global_index] + else + SymbolWithLoc{ .sym_index = target_sym_index, .file = object_id + 1 }; + break :blk target; + }, + else => unreachable, + } + }; + log.debug("FDE at offset {x} tracks {s}", .{ offset, zld.getSymbolName(target) }); + if (target.getFile() != object_id) { + self.eh_frame_relocs_lookup.getPtr(offset).?.dead = true; + } else { + const atom_index = self.getAtomIndexForSymbol(target.sym_index).?; + self.eh_frame_records_lookup.putAssumeCapacityNoClobber(atom_index, offset); + } + } + } +} + +fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void { + const sect = self.unwind_info_sect orelse { + // If it so happens that the object had `__eh_frame` section defined but no `__compact_unwind`, + // we will try fully synthesising unwind info records to somewhat match Apple ld's + // approach. However, we will only synthesise DWARF records and nothing more. For this reason, + // we still create the output `__TEXT,__unwind_info` section. + if (self.eh_frame_sect != null) { + if (zld.getSectionByName("__TEXT", "__unwind_info") == null) { + _ = try zld.initSection("__TEXT", "__unwind_info", .{}); + } + } + return; + }; + + log.debug("parsing unwind info in {s}", .{self.name}); + + const gpa = zld.gpa; + const cpu_arch = zld.options.target.cpu.arch; + + if (zld.getSectionByName("__TEXT", "__unwind_info") == null) { + _ = try zld.initSection("__TEXT", "__unwind_info", .{}); + } + + try self.unwind_records_lookup.ensureTotalCapacity(gpa, @intCast(u32, self.exec_atoms.items.len)); + + const unwind_records = self.getUnwindRecords(); + + const needs_eh_frame = for (unwind_records) |record| { + if (UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) break true; + } else false; + + if (needs_eh_frame) { + if (self.eh_frame_sect == null) { + log.err("missing __TEXT,__eh_frame section", .{}); + log.err(" in object {s}", .{self.name}); + return error.MissingSection; + } + } + + const relocs = self.getRelocs(sect); + for (unwind_records) |record, record_id| { + const offset = record_id * @sizeOf(macho.compact_unwind_entry); + const rel_pos = filterRelocs( + relocs, + offset, + offset + @sizeOf(macho.compact_unwind_entry), + ); + assert(rel_pos.len > 0); // TODO convert to an error as the unwind info is malformed + self.unwind_relocs_lookup[record_id] = .{ + .dead = false, + .reloc = rel_pos, + }; + + // Find function symbol that this record describes + const rel = relocs[rel_pos.start..][rel_pos.len - 1]; + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + mem.asBytes(&record), + @intCast(i32, offset), + ); + log.debug("unwind record {d} tracks {s}", .{ record_id, zld.getSymbolName(target) }); + if (target.getFile() != object_id) { + self.unwind_relocs_lookup[record_id].dead = true; + } else { + const atom_index = self.getAtomIndexForSymbol(target.sym_index).?; + self.unwind_records_lookup.putAssumeCapacityNoClobber(atom_index, @intCast(u32, record_id)); + } + } +} + pub fn getSourceSymbol(self: Object, index: u32) ?macho.nlist_64 { const symtab = self.in_symtab.?; if (index >= symtab.len) return null; @@ -529,23 +806,28 @@ pub fn getSourceSymbol(self: Object, index: u32) ?macho.nlist_64 { return symtab[mapped_index]; } -/// Expects an arena allocator. -/// Caller owns memory. -pub fn createReverseSymbolLookup(self: Object, arena: Allocator) ![]u32 { - const symtab = self.in_symtab orelse return &[0]u32{}; - const lookup = try arena.alloc(u32, symtab.len); - for (self.source_symtab_lookup) |source_id, id| { - lookup[source_id] = @intCast(u32, id); - } - return lookup; -} - pub fn getSourceSection(self: Object, index: u16) macho.section_64 { const sections = self.getSourceSections(); assert(index < sections.len); return sections[index]; } +pub fn getSourceSectionByName(self: Object, segname: []const u8, sectname: []const u8) ?macho.section_64 { + const sections = self.getSourceSections(); + for (sections) |sect| { + if (mem.eql(u8, segname, sect.segName()) and mem.eql(u8, sectname, sect.sectName())) + return sect; + } else return null; +} + +pub fn getSourceSectionIndexByName(self: Object, segname: []const u8, sectname: []const u8) ?u8 { + const sections = self.getSourceSections(); + for (sections) |sect, i| { + if (mem.eql(u8, segname, sect.segName()) and mem.eql(u8, sectname, sect.sectName())) + return @intCast(u8, i + 1); + } else return null; +} + pub fn getSourceSections(self: Object) []const macho.section_64 { var it = LoadCommandIterator{ .ncmds = self.header.ncmds, @@ -652,8 +934,64 @@ pub fn getSymbolName(self: Object, index: u32) []const u8 { return strtab[start..][0 .. len - 1 :0]; } +pub fn getSymbolByAddress(self: Object, addr: u64, sect_hint: ?u8) u32 { + // Find containing atom + const Predicate = struct { + addr: i64, + + pub fn predicate(pred: @This(), other: i64) bool { + return if (other == -1) true else other > pred.addr; + } + }; + + if (sect_hint) |sect_id| { + if (self.source_section_index_lookup[sect_id] > -1) { + const first_sym_index = @intCast(usize, self.source_section_index_lookup[sect_id]); + const target_sym_index = @import("zld.zig").lsearch(i64, self.source_address_lookup[first_sym_index..], Predicate{ + .addr = @intCast(i64, addr), + }); + if (target_sym_index > 0) { + return @intCast(u32, first_sym_index + target_sym_index - 1); + } + } + return self.getSectionAliasSymbolIndex(sect_id); + } + + const target_sym_index = @import("zld.zig").lsearch(i64, self.source_address_lookup, Predicate{ + .addr = @intCast(i64, addr), + }); + assert(target_sym_index > 0); + return @intCast(u32, target_sym_index - 1); +} + +pub fn getGlobal(self: Object, sym_index: u32) ?u32 { + if (self.globals_lookup[sym_index] == -1) return null; + return @intCast(u32, self.globals_lookup[sym_index]); +} + pub fn getAtomIndexForSymbol(self: Object, sym_index: u32) ?AtomIndex { const atom_index = self.atom_by_index_table[sym_index]; if (atom_index == 0) return null; return atom_index; } + +pub fn hasUnwindRecords(self: Object) bool { + return self.unwind_info_sect != null; +} + +pub fn getUnwindRecords(self: Object) []align(1) const macho.compact_unwind_entry { + const sect = self.unwind_info_sect orelse return &[0]macho.compact_unwind_entry{}; + const data = self.getSectionContents(sect); + const num_entries = @divExact(data.len, @sizeOf(macho.compact_unwind_entry)); + return @ptrCast([*]align(1) const macho.compact_unwind_entry, data)[0..num_entries]; +} + +pub fn hasEhFrameRecords(self: Object) bool { + return self.eh_frame_sect != null; +} + +pub fn getEhFrameRecordsIterator(self: Object) eh_frame.Iterator { + const sect = self.eh_frame_sect orelse return .{ .data = &[0]u8{} }; + const data = self.getSectionContents(sect); + return .{ .data = data }; +} diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig new file mode 100644 index 0000000000..07091af08a --- /dev/null +++ b/src/link/MachO/UnwindInfo.zig @@ -0,0 +1,845 @@ +const UnwindInfo = @This(); + +const std = @import("std"); +const assert = std.debug.assert; +const eh_frame = @import("eh_frame.zig"); +const fs = std.fs; +const leb = std.leb; +const log = std.log.scoped(.unwind_info); +const macho = std.macho; +const math = std.math; +const mem = std.mem; +const trace = @import("../../tracy.zig").trace; + +const Allocator = mem.Allocator; +const Atom = @import("ZldAtom.zig"); +const AtomIndex = @import("zld.zig").AtomIndex; +const EhFrameRecord = eh_frame.EhFrameRecord; +const Object = @import("Object.zig"); +const SymbolWithLoc = @import("zld.zig").SymbolWithLoc; +const Zld = @import("zld.zig").Zld; + +const N_DEAD = @import("zld.zig").N_DEAD; + +gpa: Allocator, + +/// List of all unwind records gathered from all objects and sorted +/// by source function address. +records: std.ArrayListUnmanaged(macho.compact_unwind_entry) = .{}, +records_lookup: std.AutoHashMapUnmanaged(AtomIndex, RecordIndex) = .{}, + +/// List of all personalities referenced by either unwind info entries +/// or __eh_frame entries. +personalities: [max_personalities]SymbolWithLoc = undefined, +personalities_count: u2 = 0, + +/// List of common encodings sorted in descending order with the most common first. +common_encodings: [max_common_encodings]macho.compact_unwind_encoding_t = undefined, +common_encodings_count: u7 = 0, + +/// List of record indexes containing an LSDA pointer. +lsdas: std.ArrayListUnmanaged(RecordIndex) = .{}, +lsdas_lookup: std.AutoHashMapUnmanaged(RecordIndex, u32) = .{}, + +/// List of second level pages. +pages: std.ArrayListUnmanaged(Page) = .{}, + +const RecordIndex = u32; + +const max_personalities = 3; +const max_common_encodings = 127; +const max_compact_encodings = 256; + +const second_level_page_bytes = 0x1000; +const second_level_page_words = second_level_page_bytes / @sizeOf(u32); + +const max_regular_second_level_entries = + (second_level_page_bytes - @sizeOf(macho.unwind_info_regular_second_level_page_header)) / + @sizeOf(macho.unwind_info_regular_second_level_entry); + +const max_compressed_second_level_entries = + (second_level_page_bytes - @sizeOf(macho.unwind_info_compressed_second_level_page_header)) / + @sizeOf(u32); + +const compressed_entry_func_offset_mask = ~@as(u24, 0); + +const Page = struct { + kind: enum { regular, compressed }, + start: RecordIndex, + count: u16, + page_encodings: [max_compact_encodings]RecordIndex = undefined, + page_encodings_count: u8 = 0, + + fn appendPageEncoding(page: *Page, record_id: RecordIndex) void { + assert(page.page_encodings_count <= max_compact_encodings); + page.page_encodings[page.page_encodings_count] = record_id; + page.page_encodings_count += 1; + } + + fn getPageEncoding( + page: *const Page, + info: *const UnwindInfo, + enc: macho.compact_unwind_encoding_t, + ) ?u8 { + comptime var index: u8 = 0; + inline while (index < max_compact_encodings) : (index += 1) { + if (index >= page.page_encodings_count) return null; + const record_id = page.page_encodings[index]; + const record = info.records.items[record_id]; + if (record.compactUnwindEncoding == enc) { + return index; + } + } + return null; + } + + fn format( + page: *const Page, + comptime unused_format_string: []const u8, + options: std.fmt.FormatOptions, + writer: anytype, + ) !void { + _ = page; + _ = unused_format_string; + _ = options; + _ = writer; + @compileError("do not format Page directly; use page.fmtDebug()"); + } + + const DumpCtx = struct { + page: *const Page, + info: *const UnwindInfo, + }; + + fn dump( + ctx: DumpCtx, + comptime unused_format_string: []const u8, + options: std.fmt.FormatOptions, + writer: anytype, + ) @TypeOf(writer).Error!void { + _ = options; + comptime assert(unused_format_string.len == 0); + try writer.writeAll("Page:\n"); + try writer.print(" kind: {s}\n", .{@tagName(ctx.page.kind)}); + try writer.print(" entries: {d} - {d}\n", .{ + ctx.page.start, + ctx.page.start + ctx.page.count, + }); + try writer.print(" encodings (count = {d})\n", .{ctx.page.page_encodings_count}); + for (ctx.page.page_encodings[0..ctx.page.page_encodings_count]) |record_id, i| { + const record = ctx.info.records.items[record_id]; + const enc = record.compactUnwindEncoding; + try writer.print(" {d}: 0x{x:0>8}\n", .{ ctx.info.common_encodings_count + i, enc }); + } + } + + fn fmtDebug(page: *const Page, info: *const UnwindInfo) std.fmt.Formatter(dump) { + return .{ .data = .{ + .page = page, + .info = info, + } }; + } + + fn write(page: *const Page, info: *const UnwindInfo, writer: anytype) !void { + switch (page.kind) { + .regular => { + try writer.writeStruct(macho.unwind_info_regular_second_level_page_header{ + .entryPageOffset = @sizeOf(macho.unwind_info_regular_second_level_page_header), + .entryCount = page.count, + }); + + for (info.records.items[page.start..][0..page.count]) |record| { + try writer.writeStruct(macho.unwind_info_regular_second_level_entry{ + .functionOffset = @intCast(u32, record.rangeStart), + .encoding = record.compactUnwindEncoding, + }); + } + }, + .compressed => { + const entry_offset = @sizeOf(macho.unwind_info_compressed_second_level_page_header) + + @intCast(u16, page.page_encodings_count) * @sizeOf(u32); + try writer.writeStruct(macho.unwind_info_compressed_second_level_page_header{ + .entryPageOffset = entry_offset, + .entryCount = page.count, + .encodingsPageOffset = @sizeOf( + macho.unwind_info_compressed_second_level_page_header, + ), + .encodingsCount = page.page_encodings_count, + }); + + for (page.page_encodings[0..page.page_encodings_count]) |record_id| { + const enc = info.records.items[record_id].compactUnwindEncoding; + try writer.writeIntLittle(u32, enc); + } + + assert(page.count > 0); + const first_entry = info.records.items[page.start]; + for (info.records.items[page.start..][0..page.count]) |record| { + const enc_index = blk: { + if (info.getCommonEncoding(record.compactUnwindEncoding)) |id| { + break :blk id; + } + const ncommon = info.common_encodings_count; + break :blk ncommon + page.getPageEncoding(info, record.compactUnwindEncoding).?; + }; + const compressed = macho.UnwindInfoCompressedEntry{ + .funcOffset = @intCast(u24, record.rangeStart - first_entry.rangeStart), + .encodingIndex = @intCast(u8, enc_index), + }; + try writer.writeStruct(compressed); + } + }, + } + } +}; + +pub fn deinit(info: *UnwindInfo) void { + info.records.deinit(info.gpa); + info.records_lookup.deinit(info.gpa); + info.pages.deinit(info.gpa); + info.lsdas.deinit(info.gpa); + info.lsdas_lookup.deinit(info.gpa); +} + +pub fn scanRelocs(zld: *Zld) !void { + if (zld.getSectionByName("__TEXT", "__unwind_info") == null) return; + + const cpu_arch = zld.options.target.cpu.arch; + for (zld.objects.items) |*object, object_id| { + const unwind_records = object.getUnwindRecords(); + for (object.exec_atoms.items) |atom_index| { + const record_id = object.unwind_records_lookup.get(atom_index) orelse continue; + if (object.unwind_relocs_lookup[record_id].dead) continue; + const record = unwind_records[record_id]; + if (!UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) { + if (getPersonalityFunctionReloc( + zld, + @intCast(u32, object_id), + record_id, + )) |rel| { + // Personality function; add GOT pointer. + const target = parseRelocTarget( + zld, + @intCast(u32, object_id), + rel, + mem.asBytes(&record), + @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)), + ); + try Atom.addGotEntry(zld, target); + } + } + } + } +} + +pub fn collect(info: *UnwindInfo, zld: *Zld) !void { + if (zld.getSectionByName("__TEXT", "__unwind_info") == null) return; + + const cpu_arch = zld.options.target.cpu.arch; + + var records = std.ArrayList(macho.compact_unwind_entry).init(info.gpa); + defer records.deinit(); + + var atom_indexes = std.ArrayList(AtomIndex).init(info.gpa); + defer atom_indexes.deinit(); + + // TODO handle dead stripping + for (zld.objects.items) |*object, object_id| { + log.debug("collecting unwind records in {s} ({d})", .{ object.name, object_id }); + const unwind_records = object.getUnwindRecords(); + + // Contents of unwind records does not have to cover all symbol in executable section + // so we need insert them ourselves. + try records.ensureUnusedCapacity(object.exec_atoms.items.len); + try atom_indexes.ensureUnusedCapacity(object.exec_atoms.items.len); + + for (object.exec_atoms.items) |atom_index| { + var record = if (object.unwind_records_lookup.get(atom_index)) |record_id| blk: { + if (object.unwind_relocs_lookup[record_id].dead) continue; + var record = unwind_records[record_id]; + + if (UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) { + try info.collectPersonalityFromDwarf(zld, @intCast(u32, object_id), atom_index, &record); + } else { + if (getPersonalityFunctionReloc( + zld, + @intCast(u32, object_id), + record_id, + )) |rel| { + const target = parseRelocTarget( + zld, + @intCast(u32, object_id), + rel, + mem.asBytes(&record), + @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)), + ); + const personality_index = info.getPersonalityFunction(target) orelse inner: { + const personality_index = info.personalities_count; + info.personalities[personality_index] = target; + info.personalities_count += 1; + break :inner personality_index; + }; + + record.personalityFunction = personality_index + 1; + UnwindEncoding.setPersonalityIndex(&record.compactUnwindEncoding, personality_index + 1); + } + + if (getLsdaReloc(zld, @intCast(u32, object_id), record_id)) |rel| { + const target = parseRelocTarget( + zld, + @intCast(u32, object_id), + rel, + mem.asBytes(&record), + @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)), + ); + record.lsda = @bitCast(u64, target); + } + } + break :blk record; + } else blk: { + const atom = zld.getAtom(atom_index); + const sym = zld.getSymbol(atom.getSymbolWithLoc()); + if (sym.n_desc == N_DEAD) continue; + + if (!object.hasUnwindRecords()) { + if (object.eh_frame_records_lookup.get(atom_index)) |fde_offset| { + if (object.eh_frame_relocs_lookup.get(fde_offset).?.dead) continue; + var record = nullRecord(); + try info.collectPersonalityFromDwarf(zld, @intCast(u32, object_id), atom_index, &record); + switch (cpu_arch) { + .aarch64 => UnwindEncoding.setMode(&record.compactUnwindEncoding, macho.UNWIND_ARM64_MODE.DWARF), + .x86_64 => UnwindEncoding.setMode(&record.compactUnwindEncoding, macho.UNWIND_X86_64_MODE.DWARF), + else => unreachable, + } + break :blk record; + } + } + + break :blk nullRecord(); + }; + + const atom = zld.getAtom(atom_index); + const sym_loc = atom.getSymbolWithLoc(); + const sym = zld.getSymbol(sym_loc); + assert(sym.n_desc != N_DEAD); + record.rangeStart = sym.n_value; + record.rangeLength = @intCast(u32, atom.size); + + records.appendAssumeCapacity(record); + atom_indexes.appendAssumeCapacity(atom_index); + } + } + + // Fold records + try info.records.ensureTotalCapacity(info.gpa, records.items.len); + try info.records_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, atom_indexes.items.len)); + + var maybe_prev: ?macho.compact_unwind_entry = null; + for (records.items) |record, i| { + const record_id = blk: { + if (maybe_prev) |prev| { + const is_dwarf = UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch); + if (is_dwarf or + (prev.compactUnwindEncoding != record.compactUnwindEncoding) or + (prev.personalityFunction != record.personalityFunction) or + record.lsda > 0) + { + const record_id = @intCast(RecordIndex, info.records.items.len); + info.records.appendAssumeCapacity(record); + maybe_prev = record; + break :blk record_id; + } else { + break :blk @intCast(RecordIndex, info.records.items.len - 1); + } + } else { + const record_id = @intCast(RecordIndex, info.records.items.len); + info.records.appendAssumeCapacity(record); + maybe_prev = record; + break :blk record_id; + } + }; + info.records_lookup.putAssumeCapacityNoClobber(atom_indexes.items[i], record_id); + } + + // Calculate common encodings + { + const CommonEncWithCount = struct { + enc: macho.compact_unwind_encoding_t, + count: u32, + + fn greaterThan(ctx: void, lhs: @This(), rhs: @This()) bool { + _ = ctx; + return lhs.count > rhs.count; + } + }; + + const Context = struct { + pub fn hash(ctx: @This(), key: macho.compact_unwind_encoding_t) u32 { + _ = ctx; + return key; + } + + pub fn eql( + ctx: @This(), + key1: macho.compact_unwind_encoding_t, + key2: macho.compact_unwind_encoding_t, + b_index: usize, + ) bool { + _ = ctx; + _ = b_index; + return key1 == key2; + } + }; + + var common_encodings_counts = std.ArrayHashMap( + macho.compact_unwind_encoding_t, + CommonEncWithCount, + Context, + false, + ).init(info.gpa); + defer common_encodings_counts.deinit(); + + for (info.records.items) |record| { + assert(!isNull(record)); + if (UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) continue; + const enc = record.compactUnwindEncoding; + const gop = try common_encodings_counts.getOrPut(enc); + if (!gop.found_existing) { + gop.value_ptr.* = .{ + .enc = enc, + .count = 0, + }; + } + gop.value_ptr.count += 1; + } + + var slice = common_encodings_counts.values(); + std.sort.sort(CommonEncWithCount, slice, {}, CommonEncWithCount.greaterThan); + + var i: u7 = 0; + while (i < slice.len) : (i += 1) { + if (i >= max_common_encodings) break; + if (slice[i].count < 2) continue; + info.appendCommonEncoding(slice[i].enc); + log.debug("adding common encoding: {d} => 0x{x:0>8}", .{ i, slice[i].enc }); + } + } + + // Compute page allocations + { + var i: u32 = 0; + while (i < info.records.items.len) { + const range_start_max: u64 = + info.records.items[i].rangeStart + compressed_entry_func_offset_mask; + var encoding_count: u9 = info.common_encodings_count; + var space_left: u32 = second_level_page_words - + @sizeOf(macho.unwind_info_compressed_second_level_page_header) / @sizeOf(u32); + var page = Page{ + .kind = undefined, + .start = i, + .count = 0, + }; + + while (space_left >= 1 and i < info.records.items.len) { + const record = info.records.items[i]; + const enc = record.compactUnwindEncoding; + const is_dwarf = UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch); + + if (record.rangeStart >= range_start_max) { + break; + } else if (info.getCommonEncoding(enc) != null or + page.getPageEncoding(info, enc) != null and !is_dwarf) + { + i += 1; + space_left -= 1; + } else if (space_left >= 2 and encoding_count < max_compact_encodings) { + page.appendPageEncoding(i); + i += 1; + space_left -= 2; + encoding_count += 1; + } else { + break; + } + } + + page.count = @intCast(u16, i - page.start); + + if (i < info.records.items.len and page.count < max_regular_second_level_entries) { + page.kind = .regular; + page.count = @intCast(u16, @min( + max_regular_second_level_entries, + info.records.items.len - page.start, + )); + i = page.start + page.count; + } else { + page.kind = .compressed; + } + + log.debug("{}", .{page.fmtDebug(info)}); + + try info.pages.append(info.gpa, page); + } + } + + // Save indices of records requiring LSDA relocation + try info.lsdas_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, info.records.items.len)); + for (info.records.items) |rec, i| { + info.lsdas_lookup.putAssumeCapacityNoClobber(@intCast(RecordIndex, i), @intCast(u32, info.lsdas.items.len)); + if (rec.lsda == 0) continue; + try info.lsdas.append(info.gpa, @intCast(RecordIndex, i)); + } +} + +fn collectPersonalityFromDwarf( + info: *UnwindInfo, + zld: *Zld, + object_id: u32, + atom_index: u32, + record: *macho.compact_unwind_entry, +) !void { + const object = &zld.objects.items[object_id]; + var it = object.getEhFrameRecordsIterator(); + const fde_offset = object.eh_frame_records_lookup.get(atom_index).?; + it.seekTo(fde_offset); + const fde = (try it.next()).?; + const cie_ptr = fde.getCiePointer(); + const cie_offset = fde_offset + 4 - cie_ptr; + it.seekTo(cie_offset); + const cie = (try it.next()).?; + + if (cie.getPersonalityPointerReloc( + zld, + @intCast(u32, object_id), + cie_offset, + )) |target| { + const personality_index = info.getPersonalityFunction(target) orelse inner: { + const personality_index = info.personalities_count; + info.personalities[personality_index] = target; + info.personalities_count += 1; + break :inner personality_index; + }; + + record.personalityFunction = personality_index + 1; + UnwindEncoding.setPersonalityIndex(&record.compactUnwindEncoding, personality_index + 1); + } +} + +pub fn calcSectionSize(info: UnwindInfo, zld: *Zld) !void { + const sect_id = zld.getSectionByName("__TEXT", "__unwind_info") orelse return; + const sect = &zld.sections.items(.header)[sect_id]; + sect.@"align" = 2; + sect.size = info.calcRequiredSize(); +} + +fn calcRequiredSize(info: UnwindInfo) usize { + var total_size: usize = 0; + total_size += @sizeOf(macho.unwind_info_section_header); + total_size += + @intCast(usize, info.common_encodings_count) * @sizeOf(macho.compact_unwind_encoding_t); + total_size += @intCast(usize, info.personalities_count) * @sizeOf(u32); + total_size += (info.pages.items.len + 1) * @sizeOf(macho.unwind_info_section_header_index_entry); + total_size += info.lsdas.items.len * @sizeOf(macho.unwind_info_section_header_lsda_index_entry); + total_size += info.pages.items.len * second_level_page_bytes; + return total_size; +} + +pub fn write(info: *UnwindInfo, zld: *Zld) !void { + const sect_id = zld.getSectionByName("__TEXT", "__unwind_info") orelse return; + const sect = &zld.sections.items(.header)[sect_id]; + const seg_id = zld.sections.items(.segment_index)[sect_id]; + const seg = zld.segments.items[seg_id]; + + const text_sect_id = zld.getSectionByName("__TEXT", "__text").?; + const text_sect = zld.sections.items(.header)[text_sect_id]; + + var personalities: [max_personalities]u32 = undefined; + const cpu_arch = zld.options.target.cpu.arch; + + log.debug("Personalities:", .{}); + for (info.personalities[0..info.personalities_count]) |target, i| { + const atom_index = zld.getGotAtomIndexForSymbol(target).?; + const atom = zld.getAtom(atom_index); + const sym = zld.getSymbol(atom.getSymbolWithLoc()); + personalities[i] = @intCast(u32, sym.n_value - seg.vmaddr); + log.debug(" {d}: 0x{x} ({s})", .{ i, personalities[i], zld.getSymbolName(target) }); + } + + for (info.records.items) |*rec| { + // Finalize missing address values + rec.rangeStart += text_sect.addr - seg.vmaddr; + if (rec.personalityFunction > 0) { + const index = math.cast(usize, rec.personalityFunction - 1) orelse return error.Overflow; + rec.personalityFunction = personalities[index]; + } + + if (rec.compactUnwindEncoding > 0 and !UnwindEncoding.isDwarf(rec.compactUnwindEncoding, cpu_arch)) { + const lsda_target = @bitCast(SymbolWithLoc, rec.lsda); + if (lsda_target.getFile()) |_| { + const sym = zld.getSymbol(lsda_target); + rec.lsda = sym.n_value - seg.vmaddr; + } + } + } + + for (info.records.items) |record, i| { + log.debug("Unwind record at offset 0x{x}", .{i * @sizeOf(macho.compact_unwind_entry)}); + log.debug(" start: 0x{x}", .{record.rangeStart}); + log.debug(" length: 0x{x}", .{record.rangeLength}); + log.debug(" compact encoding: 0x{x:0>8}", .{record.compactUnwindEncoding}); + log.debug(" personality: 0x{x}", .{record.personalityFunction}); + log.debug(" LSDA: 0x{x}", .{record.lsda}); + } + + var buffer = std.ArrayList(u8).init(info.gpa); + defer buffer.deinit(); + + const size = info.calcRequiredSize(); + try buffer.ensureTotalCapacityPrecise(size); + + var cwriter = std.io.countingWriter(buffer.writer()); + const writer = cwriter.writer(); + + const common_encodings_offset: u32 = @sizeOf(macho.unwind_info_section_header); + const common_encodings_count: u32 = info.common_encodings_count; + const personalities_offset: u32 = common_encodings_offset + common_encodings_count * @sizeOf(u32); + const personalities_count: u32 = info.personalities_count; + const indexes_offset: u32 = personalities_offset + personalities_count * @sizeOf(u32); + const indexes_count: u32 = @intCast(u32, info.pages.items.len + 1); + + try writer.writeStruct(macho.unwind_info_section_header{ + .commonEncodingsArraySectionOffset = common_encodings_offset, + .commonEncodingsArrayCount = common_encodings_count, + .personalityArraySectionOffset = personalities_offset, + .personalityArrayCount = personalities_count, + .indexSectionOffset = indexes_offset, + .indexCount = indexes_count, + }); + + try writer.writeAll(mem.sliceAsBytes(info.common_encodings[0..info.common_encodings_count])); + try writer.writeAll(mem.sliceAsBytes(personalities[0..info.personalities_count])); + + const pages_base_offset = @intCast(u32, size - (info.pages.items.len * second_level_page_bytes)); + const lsda_base_offset = @intCast(u32, pages_base_offset - + (info.lsdas.items.len * @sizeOf(macho.unwind_info_section_header_lsda_index_entry))); + for (info.pages.items) |page, i| { + assert(page.count > 0); + const first_entry = info.records.items[page.start]; + try writer.writeStruct(macho.unwind_info_section_header_index_entry{ + .functionOffset = @intCast(u32, first_entry.rangeStart), + .secondLevelPagesSectionOffset = @intCast(u32, pages_base_offset + i * second_level_page_bytes), + .lsdaIndexArraySectionOffset = lsda_base_offset + + info.lsdas_lookup.get(page.start).? * @sizeOf(macho.unwind_info_section_header_lsda_index_entry), + }); + } + + const last_entry = info.records.items[info.records.items.len - 1]; + const sentinel_address = @intCast(u32, last_entry.rangeStart + last_entry.rangeLength); + try writer.writeStruct(macho.unwind_info_section_header_index_entry{ + .functionOffset = sentinel_address, + .secondLevelPagesSectionOffset = 0, + .lsdaIndexArraySectionOffset = lsda_base_offset + + @intCast(u32, info.lsdas.items.len) * @sizeOf(macho.unwind_info_section_header_lsda_index_entry), + }); + + for (info.lsdas.items) |record_id| { + const record = info.records.items[record_id]; + try writer.writeStruct(macho.unwind_info_section_header_lsda_index_entry{ + .functionOffset = @intCast(u32, record.rangeStart), + .lsdaOffset = @intCast(u32, record.lsda), + }); + } + + for (info.pages.items) |page| { + const start = cwriter.bytes_written; + try page.write(info, writer); + const nwritten = cwriter.bytes_written - start; + if (nwritten < second_level_page_bytes) { + const offset = math.cast(usize, second_level_page_bytes - nwritten) orelse return error.Overflow; + try writer.writeByteNTimes(0, offset); + } + } + + const padding = buffer.items.len - cwriter.bytes_written; + if (padding > 0) { + const offset = math.cast(usize, cwriter.bytes_written) orelse return error.Overflow; + mem.set(u8, buffer.items[offset..], 0); + } + + try zld.file.pwriteAll(buffer.items, sect.offset); +} + +pub fn parseRelocTarget( + zld: *Zld, + object_id: u32, + rel: macho.relocation_info, + code: []const u8, + base_offset: i32, +) SymbolWithLoc { + const tracy = trace(@src()); + defer tracy.end(); + + const object = &zld.objects.items[object_id]; + + const sym_index = if (rel.r_extern == 0) blk: { + const sect_id = @intCast(u8, rel.r_symbolnum - 1); + const rel_offset = @intCast(u32, rel.r_address - base_offset); + assert(rel.r_pcrel == 0 and rel.r_length == 3); + const address_in_section = mem.readIntLittle(u64, code[rel_offset..][0..8]); + const sym_index = object.getSymbolByAddress(address_in_section, sect_id); + break :blk sym_index; + } else object.reverse_symtab_lookup[rel.r_symbolnum]; + + const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id + 1 }; + const sym = zld.getSymbol(sym_loc); + + if (sym.sect() and !sym.ext()) { + // Make sure we are not dealing with a local alias. + const atom_index = object.getAtomIndexForSymbol(sym_index) orelse + return sym_loc; + const atom = zld.getAtom(atom_index); + return atom.getSymbolWithLoc(); + } else if (object.getGlobal(sym_index)) |global_index| { + return zld.globals.items[global_index]; + } else return sym_loc; +} + +fn getRelocs( + zld: *Zld, + object_id: u32, + record_id: usize, +) []align(1) const macho.relocation_info { + const object = &zld.objects.items[object_id]; + assert(object.hasUnwindRecords()); + const rel_pos = object.unwind_relocs_lookup[record_id].reloc; + const relocs = object.getRelocs(object.unwind_info_sect.?); + return relocs[rel_pos.start..][0..rel_pos.len]; +} + +fn isPersonalityFunction(record_id: usize, rel: macho.relocation_info) bool { + const base_offset = @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)); + const rel_offset = rel.r_address - base_offset; + return rel_offset == 16; +} + +pub fn getPersonalityFunctionReloc( + zld: *Zld, + object_id: u32, + record_id: usize, +) ?macho.relocation_info { + const relocs = getRelocs(zld, object_id, record_id); + for (relocs) |rel| { + if (isPersonalityFunction(record_id, rel)) return rel; + } + return null; +} + +fn getPersonalityFunction(info: UnwindInfo, global_index: SymbolWithLoc) ?u2 { + comptime var index: u2 = 0; + inline while (index < max_personalities) : (index += 1) { + if (index >= info.personalities_count) return null; + if (info.personalities[index].eql(global_index)) { + return index; + } + } + return null; +} + +fn isLsda(record_id: usize, rel: macho.relocation_info) bool { + const base_offset = @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)); + const rel_offset = rel.r_address - base_offset; + return rel_offset == 24; +} + +pub fn getLsdaReloc(zld: *Zld, object_id: u32, record_id: usize) ?macho.relocation_info { + const relocs = getRelocs(zld, object_id, record_id); + for (relocs) |rel| { + if (isLsda(record_id, rel)) return rel; + } + return null; +} + +pub fn isNull(rec: macho.compact_unwind_entry) bool { + return rec.rangeStart == 0 and + rec.rangeLength == 0 and + rec.compactUnwindEncoding == 0 and + rec.lsda == 0 and + rec.personalityFunction == 0; +} + +inline fn nullRecord() macho.compact_unwind_entry { + return .{ + .rangeStart = 0, + .rangeLength = 0, + .compactUnwindEncoding = 0, + .personalityFunction = 0, + .lsda = 0, + }; +} + +fn appendCommonEncoding(info: *UnwindInfo, enc: macho.compact_unwind_encoding_t) void { + assert(info.common_encodings_count <= max_common_encodings); + info.common_encodings[info.common_encodings_count] = enc; + info.common_encodings_count += 1; +} + +fn getCommonEncoding(info: UnwindInfo, enc: macho.compact_unwind_encoding_t) ?u7 { + comptime var index: u7 = 0; + inline while (index < max_common_encodings) : (index += 1) { + if (index >= info.common_encodings_count) return null; + if (info.common_encodings[index] == enc) { + return index; + } + } + return null; +} + +pub const UnwindEncoding = struct { + pub fn getMode(enc: macho.compact_unwind_encoding_t) u4 { + comptime assert(macho.UNWIND_ARM64_MODE_MASK == macho.UNWIND_X86_64_MODE_MASK); + return @truncate(u4, (enc & macho.UNWIND_ARM64_MODE_MASK) >> 24); + } + + pub fn isDwarf(enc: macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch) bool { + const mode = getMode(enc); + return switch (cpu_arch) { + .aarch64 => @intToEnum(macho.UNWIND_ARM64_MODE, mode) == .DWARF, + .x86_64 => @intToEnum(macho.UNWIND_X86_64_MODE, mode) == .DWARF, + else => unreachable, + }; + } + + pub fn setMode(enc: *macho.compact_unwind_encoding_t, mode: anytype) void { + enc.* |= @intCast(u32, @enumToInt(mode)) << 24; + } + + pub fn hasLsda(enc: macho.compact_unwind_encoding_t) bool { + const has_lsda = @truncate(u1, (enc & macho.UNWIND_HAS_LSDA) >> 31); + return has_lsda == 1; + } + + pub fn setHasLsda(enc: *macho.compact_unwind_encoding_t, has_lsda: bool) void { + const mask = @intCast(u32, @boolToInt(has_lsda)) << 31; + enc.* |= mask; + } + + pub fn getPersonalityIndex(enc: macho.compact_unwind_encoding_t) u2 { + const index = @truncate(u2, (enc & macho.UNWIND_PERSONALITY_MASK) >> 28); + return index; + } + + pub fn setPersonalityIndex(enc: *macho.compact_unwind_encoding_t, index: u2) void { + const mask = @intCast(u32, index) << 28; + enc.* |= mask; + } + + pub fn getDwarfSectionOffset(enc: macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch) u24 { + assert(isDwarf(enc, cpu_arch)); + const offset = @truncate(u24, enc); + return offset; + } + + pub fn setDwarfSectionOffset(enc: *macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch, offset: u24) void { + assert(isDwarf(enc.*, cpu_arch)); + enc.* |= offset; + } +}; diff --git a/src/link/MachO/ZldAtom.zig b/src/link/MachO/ZldAtom.zig index 8d4b6dfb2d..bb8b7cffb3 100644 --- a/src/link/MachO/ZldAtom.zig +++ b/src/link/MachO/ZldAtom.zig @@ -29,11 +29,11 @@ const Zld = @import("zld.zig").Zld; /// a stub trampoline, it can be found in the linkers `locals` arraylist. sym_index: u32, -/// -1 means an Atom is a synthetic Atom such as a GOT cell defined by the linker. -/// Otherwise, it is the index into appropriate object file. +/// 0 means an Atom is a synthetic Atom such as a GOT cell defined by the linker. +/// Otherwise, it is the index into appropriate object file (indexing from 1). /// Prefer using `getFile()` helper to get the file index out rather than using /// the field directly. -file: i32, +file: u32, /// If this Atom is not a synthetic Atom, i.e., references a subsection in an /// Object file, `inner_sym_index` and `inner_nsyms_trailing` tell where and if @@ -51,13 +51,6 @@ size: u64, /// For instance, aligmment of 0 should be read as 2^0 = 1 byte aligned. alignment: u32, -/// Cached index and length into the relocations records array that correspond to -/// this Atom and need to be resolved before the Atom can be committed into the -/// final linked image. -/// Do not use these fields directly. Instead, use `getAtomRelocs()` helper. -cached_relocs_start: i32, -cached_relocs_len: u32, - /// Points to the previous and next neighbours next_index: ?AtomIndex, prev_index: ?AtomIndex, @@ -66,20 +59,18 @@ pub const empty = Atom{ .sym_index = 0, .inner_sym_index = 0, .inner_nsyms_trailing = 0, - .file = -1, + .file = 0, .size = 0, .alignment = 0, - .cached_relocs_start = -1, - .cached_relocs_len = 0, .prev_index = null, .next_index = null, }; /// Returns `null` if the Atom is a synthetic Atom. /// Otherwise, returns an index into an array of Objects. -pub inline fn getFile(self: Atom) ?u31 { - if (self.file == -1) return null; - return @intCast(u31, self.file); +pub fn getFile(self: Atom) ?u32 { + if (self.file == 0) return null; + return self.file - 1; } pub inline fn getSymbolWithLoc(self: Atom) SymbolWithLoc { @@ -92,7 +83,7 @@ pub inline fn getSymbolWithLoc(self: Atom) SymbolWithLoc { const InnerSymIterator = struct { sym_index: u32, count: u32, - file: i32, + file: u32, pub fn next(it: *@This()) ?SymbolWithLoc { if (it.count == 0) return null; @@ -159,19 +150,14 @@ pub fn calcInnerSymbolOffset(zld: *Zld, atom_index: AtomIndex, sym_index: u32) u return source_sym.n_value - base_addr; } -pub fn scanAtomRelocs( - zld: *Zld, - atom_index: AtomIndex, - relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, -) !void { +pub fn scanAtomRelocs(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void { const arch = zld.options.target.cpu.arch; const atom = zld.getAtom(atom_index); assert(atom.getFile() != null); // synthetic atoms do not have relocs return switch (arch) { - .aarch64 => scanAtomRelocsArm64(zld, atom_index, relocs, reverse_lookup), - .x86_64 => scanAtomRelocsX86(zld, atom_index, relocs, reverse_lookup), + .aarch64 => scanAtomRelocsArm64(zld, atom_index, relocs), + .x86_64 => scanAtomRelocsX86(zld, atom_index, relocs), else => unreachable, }; } @@ -202,16 +188,11 @@ pub fn getRelocContext(zld: *Zld, atom_index: AtomIndex) RelocContext { }; } -pub fn parseRelocTarget( - zld: *Zld, - atom_index: AtomIndex, - rel: macho.relocation_info, - reverse_lookup: []u32, -) SymbolWithLoc { +pub fn parseRelocTarget(zld: *Zld, atom_index: AtomIndex, rel: macho.relocation_info) SymbolWithLoc { const atom = zld.getAtom(atom_index); const object = &zld.objects.items[atom.getFile().?]; - if (rel.r_extern == 0) { + const sym_index = if (rel.r_extern == 0) sym_index: { const sect_id = @intCast(u8, rel.r_symbolnum - 1); const ctx = getRelocContext(zld, atom_index); const atom_code = getAtomCode(zld, atom_index); @@ -219,9 +200,9 @@ pub fn parseRelocTarget( const address_in_section = if (rel.r_pcrel == 0) blk: { break :blk if (rel.r_length == 3) - mem.readIntLittle(i64, atom_code[rel_offset..][0..8]) + mem.readIntLittle(u64, atom_code[rel_offset..][0..8]) else - mem.readIntLittle(i32, atom_code[rel_offset..][0..4]); + mem.readIntLittle(u32, atom_code[rel_offset..][0..4]); } else blk: { const correction: u3 = switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) { .X86_64_RELOC_SIGNED => 0, @@ -232,38 +213,14 @@ pub fn parseRelocTarget( }; const addend = mem.readIntLittle(i32, atom_code[rel_offset..][0..4]); const target_address = @intCast(i64, ctx.base_addr) + rel.r_address + 4 + correction + addend; - break :blk target_address; + break :blk @intCast(u64, target_address); }; // Find containing atom - const Predicate = struct { - addr: i64, - - pub fn predicate(pred: @This(), other: i64) bool { - return if (other == -1) true else other > pred.addr; - } - }; - - if (object.source_section_index_lookup[sect_id] > -1) { - const first_sym_index = @intCast(usize, object.source_section_index_lookup[sect_id]); - const target_sym_index = @import("zld.zig").lsearch(i64, object.source_address_lookup[first_sym_index..], Predicate{ - .addr = address_in_section, - }); - - if (target_sym_index > 0) { - return SymbolWithLoc{ - .sym_index = @intCast(u32, first_sym_index + target_sym_index - 1), - .file = atom.file, - }; - } - } - - // Start of section is not contained anywhere, return synthetic atom. - const sym_index = object.getSectionAliasSymbolIndex(sect_id); - return SymbolWithLoc{ .sym_index = sym_index, .file = atom.file }; - } + const sym_index = object.getSymbolByAddress(address_in_section, sect_id); + break :sym_index sym_index; + } else object.reverse_symtab_lookup[rel.r_symbolnum]; - const sym_index = reverse_lookup[rel.r_symbolnum]; const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = atom.file, @@ -272,30 +229,12 @@ pub fn parseRelocTarget( if (sym.sect() and !sym.ext()) { return sym_loc; - } else if (object.globals_lookup[sym_index] > -1) { - const global_index = @intCast(u32, object.globals_lookup[sym_index]); + } else if (object.getGlobal(sym_index)) |global_index| { return zld.globals.items[global_index]; } else return sym_loc; } -pub fn getRelocTargetAtomIndex(zld: *Zld, rel: macho.relocation_info, target: SymbolWithLoc) ?AtomIndex { - const is_via_got = got: { - switch (zld.options.target.cpu.arch) { - .aarch64 => break :got switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) { - .ARM64_RELOC_GOT_LOAD_PAGE21, - .ARM64_RELOC_GOT_LOAD_PAGEOFF12, - .ARM64_RELOC_POINTER_TO_GOT, - => true, - else => false, - }, - .x86_64 => break :got switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) { - .X86_64_RELOC_GOT, .X86_64_RELOC_GOT_LOAD => true, - else => false, - }, - else => unreachable, - } - }; - +pub fn getRelocTargetAtomIndex(zld: *Zld, target: SymbolWithLoc, is_via_got: bool) ?AtomIndex { if (is_via_got) { return zld.getGotAtomIndexForSymbol(target).?; // panic means fatal error } @@ -314,12 +253,7 @@ pub fn getRelocTargetAtomIndex(zld: *Zld, rel: macho.relocation_info, target: Sy return object.getAtomIndexForSymbol(target.sym_index); } -fn scanAtomRelocsArm64( - zld: *Zld, - atom_index: AtomIndex, - relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, -) !void { +fn scanAtomRelocsArm64(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void { for (relocs) |rel| { const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type); @@ -332,7 +266,7 @@ fn scanAtomRelocsArm64( const atom = zld.getAtom(atom_index); const object = &zld.objects.items[atom.getFile().?]; - const sym_index = reverse_lookup[rel.r_symbolnum]; + const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum]; const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = atom.file, @@ -341,10 +275,10 @@ fn scanAtomRelocsArm64( if (sym.sect() and !sym.ext()) continue; - const target = if (object.globals_lookup[sym_index] > -1) blk: { - const global_index = @intCast(u32, object.globals_lookup[sym_index]); - break :blk zld.globals.items[global_index]; - } else sym_loc; + const target = if (object.getGlobal(sym_index)) |global_index| + zld.globals.items[global_index] + else + sym_loc; switch (rel_type) { .ARM64_RELOC_BRANCH26 => { @@ -368,12 +302,7 @@ fn scanAtomRelocsArm64( } } -fn scanAtomRelocsX86( - zld: *Zld, - atom_index: AtomIndex, - relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, -) !void { +fn scanAtomRelocsX86(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void { for (relocs) |rel| { const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type); @@ -386,7 +315,7 @@ fn scanAtomRelocsX86( const atom = zld.getAtom(atom_index); const object = &zld.objects.items[atom.getFile().?]; - const sym_index = reverse_lookup[rel.r_symbolnum]; + const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum]; const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = atom.file, @@ -395,10 +324,10 @@ fn scanAtomRelocsX86( if (sym.sect() and !sym.ext()) continue; - const target = if (object.globals_lookup[sym_index] > -1) blk: { - const global_index = @intCast(u32, object.globals_lookup[sym_index]); - break :blk zld.globals.items[global_index]; - } else sym_loc; + const target = if (object.getGlobal(sym_index)) |global_index| + zld.globals.items[global_index] + else + sym_loc; switch (rel_type) { .X86_64_RELOC_BRANCH => { @@ -432,7 +361,7 @@ fn addTlvPtrEntry(zld: *Zld, target: SymbolWithLoc) !void { try zld.tlv_ptr_table.putNoClobber(gpa, target, tlv_ptr_index); } -fn addGotEntry(zld: *Zld, target: SymbolWithLoc) !void { +pub fn addGotEntry(zld: *Zld, target: SymbolWithLoc) !void { if (zld.got_table.contains(target)) return; const gpa = zld.gpa; const atom_index = try zld.createGotAtom(); @@ -466,7 +395,6 @@ pub fn resolveRelocs( atom_index: AtomIndex, atom_code: []u8, atom_relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, ) !void { const arch = zld.options.target.cpu.arch; const atom = zld.getAtom(atom_index); @@ -480,14 +408,14 @@ pub fn resolveRelocs( const ctx = getRelocContext(zld, atom_index); return switch (arch) { - .aarch64 => resolveRelocsArm64(zld, atom_index, atom_code, atom_relocs, reverse_lookup, ctx), - .x86_64 => resolveRelocsX86(zld, atom_index, atom_code, atom_relocs, reverse_lookup, ctx), + .aarch64 => resolveRelocsArm64(zld, atom_index, atom_code, atom_relocs, ctx), + .x86_64 => resolveRelocsX86(zld, atom_index, atom_code, atom_relocs, ctx), else => unreachable, }; } -pub fn getRelocTargetAddress(zld: *Zld, rel: macho.relocation_info, target: SymbolWithLoc, is_tlv: bool) !u64 { - const target_atom_index = getRelocTargetAtomIndex(zld, rel, target) orelse { +pub fn getRelocTargetAddress(zld: *Zld, target: SymbolWithLoc, is_via_got: bool, is_tlv: bool) !u64 { + const target_atom_index = getRelocTargetAtomIndex(zld, target, is_via_got) orelse { // If there is no atom for target, we still need to check for special, atom-less // symbols such as `___dso_handle`. const target_name = zld.getSymbolName(target); @@ -499,7 +427,7 @@ pub fn getRelocTargetAddress(zld: *Zld, rel: macho.relocation_info, target: Symb log.debug(" | target ATOM(%{d}, '{s}') in object({?})", .{ target_atom.sym_index, zld.getSymbolName(target_atom.getSymbolWithLoc()), - target_atom.file, + target_atom.getFile(), }); const target_sym = zld.getSymbol(target_atom.getSymbolWithLoc()); @@ -541,7 +469,6 @@ fn resolveRelocsArm64( atom_index: AtomIndex, atom_code: []u8, atom_relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, context: RelocContext, ) !void { const atom = zld.getAtom(atom_index); @@ -565,20 +492,20 @@ fn resolveRelocsArm64( .ARM64_RELOC_SUBTRACTOR => { assert(subtractor == null); - log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{ + log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{ @tagName(rel_type), rel.r_address, rel.r_symbolnum, - atom.file, + atom.getFile(), }); - subtractor = parseRelocTarget(zld, atom_index, rel, reverse_lookup); + subtractor = parseRelocTarget(zld, atom_index, rel); continue; }, else => {}, } - const target = parseRelocTarget(zld, atom_index, rel, reverse_lookup); + const target = parseRelocTarget(zld, atom_index, rel); const rel_offset = @intCast(u32, rel.r_address - context.base_offset); log.debug(" RELA({s}) @ {x} => %{d} ('{s}') in object({?})", .{ @@ -586,19 +513,20 @@ fn resolveRelocsArm64( rel.r_address, target.sym_index, zld.getSymbolName(target), - target.file, + target.getFile(), }); const source_addr = blk: { const source_sym = zld.getSymbol(atom.getSymbolWithLoc()); break :blk source_sym.n_value + rel_offset; }; + const is_via_got = relocRequiresGot(zld, rel); const is_tlv = is_tlv: { const source_sym = zld.getSymbol(atom.getSymbolWithLoc()); const header = zld.sections.items(.header)[source_sym.n_sect - 1]; break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES; }; - const target_addr = try getRelocTargetAddress(zld, rel, target, is_tlv); + const target_addr = try getRelocTargetAddress(zld, target, is_via_got, is_tlv); log.debug(" | source_addr = 0x{x}", .{source_addr}); @@ -610,9 +538,9 @@ fn resolveRelocsArm64( } else target; log.debug(" source {s} (object({?})), target {s} (object({?}))", .{ zld.getSymbolName(atom.getSymbolWithLoc()), - atom.file, + atom.getFile(), zld.getSymbolName(target), - zld.getAtom(getRelocTargetAtomIndex(zld, rel, target).?).file, + zld.getAtom(getRelocTargetAtomIndex(zld, target, is_via_got).?).getFile(), }); const displacement = if (calcPcRelativeDisplacementArm64( @@ -628,7 +556,7 @@ fn resolveRelocsArm64( zld, actual_target, ).?); - log.debug(" | target_addr = 0x{x}", .{thunk_sym.n_value}); + log.debug(" | target_addr = 0x{x} (thunk)", .{thunk_sym.n_value}); break :blk try calcPcRelativeDisplacementArm64(source_addr, thunk_sym.n_value); }; @@ -832,7 +760,6 @@ fn resolveRelocsX86( atom_index: AtomIndex, atom_code: []u8, atom_relocs: []align(1) const macho.relocation_info, - reverse_lookup: []u32, context: RelocContext, ) !void { const atom = zld.getAtom(atom_index); @@ -847,33 +774,34 @@ fn resolveRelocsX86( .X86_64_RELOC_SUBTRACTOR => { assert(subtractor == null); - log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{ + log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{ @tagName(rel_type), rel.r_address, rel.r_symbolnum, - atom.file, + atom.getFile(), }); - subtractor = parseRelocTarget(zld, atom_index, rel, reverse_lookup); + subtractor = parseRelocTarget(zld, atom_index, rel); continue; }, else => {}, } - const target = parseRelocTarget(zld, atom_index, rel, reverse_lookup); + const target = parseRelocTarget(zld, atom_index, rel); const rel_offset = @intCast(u32, rel.r_address - context.base_offset); log.debug(" RELA({s}) @ {x} => %{d} in object({?})", .{ @tagName(rel_type), rel.r_address, target.sym_index, - target.file, + target.getFile(), }); const source_addr = blk: { const source_sym = zld.getSymbol(atom.getSymbolWithLoc()); break :blk source_sym.n_value + rel_offset; }; + const is_via_got = relocRequiresGot(zld, rel); const is_tlv = is_tlv: { const source_sym = zld.getSymbol(atom.getSymbolWithLoc()); const header = zld.sections.items(.header)[source_sym.n_sect - 1]; @@ -882,7 +810,7 @@ fn resolveRelocsX86( log.debug(" | source_addr = 0x{x}", .{source_addr}); - const target_addr = try getRelocTargetAddress(zld, rel, target, is_tlv); + const target_addr = try getRelocTargetAddress(zld, target, is_via_got, is_tlv); switch (rel_type) { .X86_64_RELOC_BRANCH => { @@ -1016,9 +944,10 @@ pub fn getAtomCode(zld: *Zld, atom_index: AtomIndex) []const u8 { } pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []align(1) const macho.relocation_info { - const atom = zld.getAtomPtr(atom_index); + const atom = zld.getAtom(atom_index); assert(atom.getFile() != null); // Synthetic atom shouldn't need to unique for relocs. const object = zld.objects.items[atom.getFile().?]; + const cache = object.relocs_lookup[atom.sym_index]; const source_sect = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: { const source_sect = object.getSourceSection(source_sym.n_sect - 1); @@ -1036,43 +965,7 @@ pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []align(1) const macho.re }; const relocs = object.getRelocs(source_sect); - - if (atom.cached_relocs_start == -1) { - const indexes = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: { - const offset = source_sym.n_value - source_sect.addr; - break :blk filterRelocs(relocs, offset, offset + atom.size); - } else filterRelocs(relocs, 0, atom.size); - atom.cached_relocs_start = indexes.start; - atom.cached_relocs_len = indexes.len; - } - - return relocs[@intCast(u32, atom.cached_relocs_start)..][0..atom.cached_relocs_len]; -} - -fn filterRelocs( - relocs: []align(1) const macho.relocation_info, - start_addr: u64, - end_addr: u64, -) struct { start: i32, len: u32 } { - const Predicate = struct { - addr: u64, - - pub fn predicate(self: @This(), rel: macho.relocation_info) bool { - return rel.r_address >= self.addr; - } - }; - const LPredicate = struct { - addr: u64, - - pub fn predicate(self: @This(), rel: macho.relocation_info) bool { - return rel.r_address < self.addr; - } - }; - - const start = @import("zld.zig").bsearch(macho.relocation_info, relocs, Predicate{ .addr = end_addr }); - const len = @import("zld.zig").lsearch(macho.relocation_info, relocs[start..], LPredicate{ .addr = start_addr }); - - return .{ .start = @intCast(i32, start), .len = @intCast(u32, len) }; + return relocs[cache.start..][0..cache.len]; } pub fn calcPcRelativeDisplacementX86(source_addr: u64, target_addr: u64, correction: u3) error{Overflow}!i32 { @@ -1111,3 +1004,22 @@ pub fn calcPageOffset(target_addr: u64, kind: PageOffsetInstKind) !u12 { .load_store_128 => try math.divExact(u12, narrowed, 16), }; } + +pub fn relocRequiresGot(zld: *Zld, rel: macho.relocation_info) bool { + switch (zld.options.target.cpu.arch) { + .aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) { + .ARM64_RELOC_GOT_LOAD_PAGE21, + .ARM64_RELOC_GOT_LOAD_PAGEOFF12, + .ARM64_RELOC_POINTER_TO_GOT, + => return true, + else => return false, + }, + .x86_64 => switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) { + .X86_64_RELOC_GOT, + .X86_64_RELOC_GOT_LOAD, + => return true, + else => return false, + }, + else => unreachable, + } +} diff --git a/src/link/MachO/dead_strip.zig b/src/link/MachO/dead_strip.zig index ab36ef8a76..1f8def96f3 100644 --- a/src/link/MachO/dead_strip.zig +++ b/src/link/MachO/dead_strip.zig @@ -2,6 +2,7 @@ const std = @import("std"); const assert = std.debug.assert; +const eh_frame = @import("eh_frame.zig"); const log = std.log.scoped(.dead_strip); const macho = std.macho; const math = std.math; @@ -11,13 +12,14 @@ const Allocator = mem.Allocator; const AtomIndex = @import("zld.zig").AtomIndex; const Atom = @import("ZldAtom.zig"); const SymbolWithLoc = @import("zld.zig").SymbolWithLoc; +const UnwindInfo = @import("UnwindInfo.zig"); const Zld = @import("zld.zig").Zld; const N_DEAD = @import("zld.zig").N_DEAD; const AtomTable = std.AutoHashMap(AtomIndex, void); -pub fn gcAtoms(zld: *Zld, reverse_lookups: [][]u32) Allocator.Error!void { +pub fn gcAtoms(zld: *Zld) !void { const gpa = zld.gpa; var arena = std.heap.ArenaAllocator.init(gpa); @@ -30,7 +32,7 @@ pub fn gcAtoms(zld: *Zld, reverse_lookups: [][]u32) Allocator.Error!void { try alive.ensureTotalCapacity(@intCast(u32, zld.atoms.items.len)); try collectRoots(zld, &roots); - mark(zld, roots, &alive, reverse_lookups); + try mark(zld, roots, &alive); prune(zld, alive); } @@ -45,10 +47,10 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void { const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error _ = try roots.getOrPut(atom_index); - log.debug("root(ATOM({d}, %{d}, {d}))", .{ + log.debug("root(ATOM({d}, %{d}, {?d}))", .{ atom_index, zld.getAtom(atom_index).sym_index, - zld.getAtom(atom_index).file, + zld.getAtom(atom_index).getFile(), }); }, else => |other| { @@ -63,32 +65,15 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void { const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error _ = try roots.getOrPut(atom_index); - log.debug("root(ATOM({d}, %{d}, {d}))", .{ + log.debug("root(ATOM({d}, %{d}, {?d}))", .{ atom_index, zld.getAtom(atom_index).sym_index, - zld.getAtom(atom_index).file, + zld.getAtom(atom_index).getFile(), }); } }, } - // TODO just a temp until we learn how to parse unwind records - for (zld.globals.items) |global| { - if (mem.eql(u8, "___gxx_personality_v0", zld.getSymbolName(global))) { - const object = zld.objects.items[global.getFile().?]; - if (object.getAtomIndexForSymbol(global.sym_index)) |atom_index| { - _ = try roots.getOrPut(atom_index); - - log.debug("root(ATOM({d}, %{d}, {d}))", .{ - atom_index, - zld.getAtom(atom_index).sym_index, - zld.getAtom(atom_index).file, - }); - } - break; - } - } - for (zld.objects.items) |object| { const has_subsections = object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0; @@ -119,28 +104,23 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void { if (is_gc_root) { try roots.putNoClobber(atom_index, {}); - log.debug("root(ATOM({d}, %{d}, {d}))", .{ + log.debug("root(ATOM({d}, %{d}, {?d}))", .{ atom_index, zld.getAtom(atom_index).sym_index, - zld.getAtom(atom_index).file, + zld.getAtom(atom_index).getFile(), }); } } } } -fn markLive( - zld: *Zld, - atom_index: AtomIndex, - alive: *AtomTable, - reverse_lookups: [][]u32, -) void { +fn markLive(zld: *Zld, atom_index: AtomIndex, alive: *AtomTable) void { if (alive.contains(atom_index)) return; const atom = zld.getAtom(atom_index); const sym_loc = atom.getSymbolWithLoc(); - log.debug("mark(ATOM({d}, %{d}, {d}))", .{ atom_index, sym_loc.sym_index, sym_loc.file }); + log.debug("mark(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() }); alive.putAssumeCapacityNoClobber(atom_index, {}); @@ -151,14 +131,13 @@ fn markLive( if (header.isZerofill()) return; const relocs = Atom.getAtomRelocs(zld, atom_index); - const reverse_lookup = reverse_lookups[atom.getFile().?]; for (relocs) |rel| { const target = switch (cpu_arch) { .aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) { .ARM64_RELOC_ADDEND => continue, - else => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup), + else => Atom.parseRelocTarget(zld, atom_index, rel), }, - .x86_64 => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup), + .x86_64 => Atom.parseRelocTarget(zld, atom_index, rel), else => unreachable, }; const target_sym = zld.getSymbol(target); @@ -174,21 +153,21 @@ fn markLive( const object = zld.objects.items[target.getFile().?]; const target_atom_index = object.getAtomIndexForSymbol(target.sym_index).?; - log.debug(" following ATOM({d}, %{d}, {d})", .{ + log.debug(" following ATOM({d}, %{d}, {?d})", .{ target_atom_index, zld.getAtom(target_atom_index).sym_index, - zld.getAtom(target_atom_index).file, + zld.getAtom(target_atom_index).getFile(), }); - markLive(zld, target_atom_index, alive, reverse_lookups); + markLive(zld, target_atom_index, alive); } } -fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookups: [][]u32) bool { +fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable) bool { const atom = zld.getAtom(atom_index); const sym_loc = atom.getSymbolWithLoc(); - log.debug("refersLive(ATOM({d}, %{d}, {d}))", .{ atom_index, sym_loc.sym_index, sym_loc.file }); + log.debug("refersLive(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() }); const cpu_arch = zld.options.target.cpu.arch; @@ -197,14 +176,13 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup assert(!header.isZerofill()); const relocs = Atom.getAtomRelocs(zld, atom_index); - const reverse_lookup = reverse_lookups[atom.getFile().?]; for (relocs) |rel| { const target = switch (cpu_arch) { .aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) { .ARM64_RELOC_ADDEND => continue, - else => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup), + else => Atom.parseRelocTarget(zld, atom_index, rel), }, - .x86_64 => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup), + .x86_64 => Atom.parseRelocTarget(zld, atom_index, rel), else => unreachable, }; @@ -214,10 +192,10 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup continue; }; if (alive.contains(target_atom_index)) { - log.debug(" refers live ATOM({d}, %{d}, {d})", .{ + log.debug(" refers live ATOM({d}, %{d}, {?d})", .{ target_atom_index, zld.getAtom(target_atom_index).sym_index, - zld.getAtom(target_atom_index).file, + zld.getAtom(target_atom_index).getFile(), }); return true; } @@ -226,10 +204,10 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup return false; } -fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable, reverse_lookups: [][]u32) void { +fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void { var it = roots.keyIterator(); while (it.next()) |root| { - markLive(zld, root.*, alive, reverse_lookups); + markLive(zld, root.*, alive); } var loop: bool = true; @@ -251,14 +229,151 @@ fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable, reverse_lookups: [][]u32 const source_sect = object.getSourceSection(sect_id); if (source_sect.isDontDeadStripIfReferencesLive()) { - if (refersLive(zld, atom_index, alive.*, reverse_lookups)) { - markLive(zld, atom_index, alive, reverse_lookups); + if (refersLive(zld, atom_index, alive.*)) { + markLive(zld, atom_index, alive); loop = true; } } } } } + + for (zld.objects.items) |_, object_id| { + // Traverse unwind and eh_frame records noting if the source symbol has been marked, and if so, + // marking all references as live. + try markUnwindRecords(zld, @intCast(u32, object_id), alive); + } +} + +fn markUnwindRecords(zld: *Zld, object_id: u32, alive: *AtomTable) !void { + const object = &zld.objects.items[object_id]; + const cpu_arch = zld.options.target.cpu.arch; + + const unwind_records = object.getUnwindRecords(); + + for (object.exec_atoms.items) |atom_index| { + if (!object.hasUnwindRecords()) { + if (object.eh_frame_records_lookup.get(atom_index)) |fde_offset| { + const ptr = object.eh_frame_relocs_lookup.getPtr(fde_offset).?; + if (ptr.dead) continue; // already marked + if (!alive.contains(atom_index)) { + // Mark dead and continue. + ptr.dead = true; + } else { + // Mark references live and continue. + try markEhFrameRecord(zld, object_id, atom_index, alive); + } + continue; + } + } + + const record_id = object.unwind_records_lookup.get(atom_index) orelse continue; + if (object.unwind_relocs_lookup[record_id].dead) continue; // already marked, nothing to do + if (!alive.contains(atom_index)) { + // Mark the record dead and continue. + object.unwind_relocs_lookup[record_id].dead = true; + if (object.eh_frame_records_lookup.get(atom_index)) |fde_offset| { + object.eh_frame_relocs_lookup.getPtr(fde_offset).?.dead = true; + } + continue; + } + + const record = unwind_records[record_id]; + if (UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) { + try markEhFrameRecord(zld, object_id, atom_index, alive); + } else { + if (UnwindInfo.getPersonalityFunctionReloc(zld, object_id, record_id)) |rel| { + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + mem.asBytes(&record), + @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)), + ); + const target_sym = zld.getSymbol(target); + if (!target_sym.undf()) { + const target_object = zld.objects.items[target.getFile().?]; + const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?; + markLive(zld, target_atom_index, alive); + } + } + + if (UnwindInfo.getLsdaReloc(zld, object_id, record_id)) |rel| { + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + mem.asBytes(&record), + @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)), + ); + const target_object = zld.objects.items[target.getFile().?]; + const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?; + markLive(zld, target_atom_index, alive); + } + } + } +} + +fn markEhFrameRecord(zld: *Zld, object_id: u32, atom_index: AtomIndex, alive: *AtomTable) !void { + const cpu_arch = zld.options.target.cpu.arch; + const object = &zld.objects.items[object_id]; + var it = object.getEhFrameRecordsIterator(); + + const fde_offset = object.eh_frame_records_lookup.get(atom_index).?; + it.seekTo(fde_offset); + const fde = (try it.next()).?; + + const cie_ptr = fde.getCiePointer(); + const cie_offset = fde_offset + 4 - cie_ptr; + it.seekTo(cie_offset); + const cie = (try it.next()).?; + + switch (cpu_arch) { + .aarch64 => { + // Mark FDE references which should include any referenced LSDA record + const relocs = eh_frame.getRelocs(zld, object_id, fde_offset); + for (relocs) |rel| { + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + fde.data, + @intCast(i32, fde_offset) + 4, + ); + const target_sym = zld.getSymbol(target); + if (!target_sym.undf()) blk: { + const target_object = zld.objects.items[target.getFile().?]; + const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index) orelse + break :blk; + markLive(zld, target_atom_index, alive); + } + } + }, + .x86_64 => { + const lsda_ptr = try fde.getLsdaPointer(cie, .{ + .base_addr = object.eh_frame_sect.?.addr, + .base_offset = fde_offset, + }); + if (lsda_ptr) |lsda_address| { + // Mark LSDA record as live + const sym_index = object.getSymbolByAddress(lsda_address, null); + const target_atom_index = object.getAtomIndexForSymbol(sym_index).?; + markLive(zld, target_atom_index, alive); + } + }, + else => unreachable, + } + + // Mark CIE references which should include any referenced personalities + // that are defined locally. + if (cie.getPersonalityPointerReloc(zld, object_id, cie_offset)) |target| { + const target_sym = zld.getSymbol(target); + if (!target_sym.undf()) { + const target_object = zld.objects.items[target.getFile().?]; + const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?; + markLive(zld, target_atom_index, alive); + } + } } fn prune(zld: *Zld, alive: AtomTable) void { @@ -275,10 +390,10 @@ fn prune(zld: *Zld, alive: AtomTable) void { const atom = zld.getAtom(atom_index); const sym_loc = atom.getSymbolWithLoc(); - log.debug("prune(ATOM({d}, %{d}, {d}))", .{ + log.debug("prune(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, - sym_loc.file, + sym_loc.getFile(), }); log.debug(" {s} in {s}", .{ zld.getSymbolName(sym_loc), object.name }); diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig new file mode 100644 index 0000000000..8345a8e4f3 --- /dev/null +++ b/src/link/MachO/eh_frame.zig @@ -0,0 +1,625 @@ +const std = @import("std"); +const assert = std.debug.assert; +const macho = std.macho; +const math = std.math; +const mem = std.mem; +const leb = std.leb; +const log = std.log.scoped(.eh_frame); + +const Allocator = mem.Allocator; +const AtomIndex = @import("zld.zig").AtomIndex; +const Atom = @import("ZldAtom.zig"); +const SymbolWithLoc = @import("zld.zig").SymbolWithLoc; +const UnwindInfo = @import("UnwindInfo.zig"); +const Zld = @import("zld.zig").Zld; + +pub fn scanRelocs(zld: *Zld) !void { + const gpa = zld.gpa; + + for (zld.objects.items) |*object, object_id| { + var cies = std.AutoHashMap(u32, void).init(gpa); + defer cies.deinit(); + + var it = object.getEhFrameRecordsIterator(); + + for (object.exec_atoms.items) |atom_index| { + const fde_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue; + if (object.eh_frame_relocs_lookup.get(fde_offset).?.dead) continue; + it.seekTo(fde_offset); + const fde = (try it.next()).?; + + const cie_ptr = fde.getCiePointer(); + const cie_offset = fde_offset + 4 - cie_ptr; + + if (!cies.contains(cie_offset)) { + try cies.putNoClobber(cie_offset, {}); + it.seekTo(cie_offset); + const cie = (try it.next()).?; + try cie.scanRelocs(zld, @intCast(u32, object_id), cie_offset); + } + } + } +} + +pub fn calcSectionSize(zld: *Zld, unwind_info: *const UnwindInfo) !void { + const sect_id = zld.getSectionByName("__TEXT", "__eh_frame") orelse return; + const sect = &zld.sections.items(.header)[sect_id]; + sect.@"align" = 3; + sect.size = 0; + + const cpu_arch = zld.options.target.cpu.arch; + const gpa = zld.gpa; + var size: u32 = 0; + + for (zld.objects.items) |*object| { + var cies = std.AutoHashMap(u32, u32).init(gpa); + defer cies.deinit(); + + var eh_it = object.getEhFrameRecordsIterator(); + + for (object.exec_atoms.items) |atom_index| { + const fde_record_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue; + if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue; + + const record_id = unwind_info.records_lookup.get(atom_index) orelse continue; + const record = unwind_info.records.items[record_id]; + + // TODO skip this check if no __compact_unwind is present + const is_dwarf = UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch); + if (!is_dwarf) continue; + + eh_it.seekTo(fde_record_offset); + const source_fde_record = (try eh_it.next()).?; + + const cie_ptr = source_fde_record.getCiePointer(); + const cie_offset = fde_record_offset + 4 - cie_ptr; + + const gop = try cies.getOrPut(cie_offset); + if (!gop.found_existing) { + eh_it.seekTo(cie_offset); + const source_cie_record = (try eh_it.next()).?; + gop.value_ptr.* = size; + size += source_cie_record.getSize(); + } + + size += source_fde_record.getSize(); + } + } + + sect.size = size; +} + +pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void { + const sect_id = zld.getSectionByName("__TEXT", "__eh_frame") orelse return; + const sect = zld.sections.items(.header)[sect_id]; + const seg_id = zld.sections.items(.segment_index)[sect_id]; + const seg = zld.segments.items[seg_id]; + + const cpu_arch = zld.options.target.cpu.arch; + const gpa = zld.gpa; + + var eh_records = std.AutoArrayHashMap(u32, EhFrameRecord(true)).init(gpa); + defer { + for (eh_records.values()) |*rec| { + rec.deinit(gpa); + } + eh_records.deinit(); + } + + var eh_frame_offset: u32 = 0; + + for (zld.objects.items) |*object, object_id| { + try eh_records.ensureUnusedCapacity(2 * @intCast(u32, object.exec_atoms.items.len)); + + var cies = std.AutoHashMap(u32, u32).init(gpa); + defer cies.deinit(); + + var eh_it = object.getEhFrameRecordsIterator(); + + for (object.exec_atoms.items) |atom_index| { + const fde_record_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue; + if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue; + + const record_id = unwind_info.records_lookup.get(atom_index) orelse continue; + const record = &unwind_info.records.items[record_id]; + + // TODO skip this check if no __compact_unwind is present + const is_dwarf = UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch); + if (!is_dwarf) continue; + + eh_it.seekTo(fde_record_offset); + const source_fde_record = (try eh_it.next()).?; + + const cie_ptr = source_fde_record.getCiePointer(); + const cie_offset = fde_record_offset + 4 - cie_ptr; + + const gop = try cies.getOrPut(cie_offset); + if (!gop.found_existing) { + eh_it.seekTo(cie_offset); + const source_cie_record = (try eh_it.next()).?; + var cie_record = try source_cie_record.toOwned(gpa); + try cie_record.relocate(zld, @intCast(u32, object_id), .{ + .source_offset = cie_offset, + .out_offset = eh_frame_offset, + .sect_addr = sect.addr, + }); + eh_records.putAssumeCapacityNoClobber(eh_frame_offset, cie_record); + gop.value_ptr.* = eh_frame_offset; + eh_frame_offset += cie_record.getSize(); + } + + var fde_record = try source_fde_record.toOwned(gpa); + fde_record.setCiePointer(eh_frame_offset + 4 - gop.value_ptr.*); + try fde_record.relocate(zld, @intCast(u32, object_id), .{ + .source_offset = fde_record_offset, + .out_offset = eh_frame_offset, + .sect_addr = sect.addr, + }); + + switch (cpu_arch) { + .aarch64 => {}, // relocs take care of LSDA pointers + .x86_64 => { + // We need to relocate target symbol address ourselves. + const atom = zld.getAtom(atom_index); + const atom_sym = zld.getSymbol(atom.getSymbolWithLoc()); + try fde_record.setTargetSymbolAddress(atom_sym.n_value, .{ + .base_addr = sect.addr, + .base_offset = eh_frame_offset, + }); + + // We need to parse LSDA pointer and relocate ourselves. + const cie_record = eh_records.get( + eh_frame_offset + 4 - fde_record.getCiePointer(), + ).?; + const source_lsda_ptr = try fde_record.getLsdaPointer(cie_record, .{ + .base_addr = object.eh_frame_sect.?.addr, + .base_offset = fde_record_offset, + }); + if (source_lsda_ptr) |ptr| { + const sym_index = object.getSymbolByAddress(ptr, null); + const sym = object.symtab[sym_index]; + try fde_record.setLsdaPointer(cie_record, sym.n_value, .{ + .base_addr = sect.addr, + .base_offset = eh_frame_offset, + }); + } + }, + else => unreachable, + } + + eh_records.putAssumeCapacityNoClobber(eh_frame_offset, fde_record); + + UnwindInfo.UnwindEncoding.setDwarfSectionOffset( + &record.compactUnwindEncoding, + cpu_arch, + @intCast(u24, eh_frame_offset), + ); + + const cie_record = eh_records.get( + eh_frame_offset + 4 - fde_record.getCiePointer(), + ).?; + const lsda_ptr = try fde_record.getLsdaPointer(cie_record, .{ + .base_addr = sect.addr, + .base_offset = eh_frame_offset, + }); + if (lsda_ptr) |ptr| { + record.lsda = ptr - seg.vmaddr; + } + + eh_frame_offset += fde_record.getSize(); + } + } + + var buffer = std.ArrayList(u8).init(gpa); + defer buffer.deinit(); + const writer = buffer.writer(); + + for (eh_records.values()) |record| { + try writer.writeIntLittle(u32, record.size); + try buffer.appendSlice(record.data); + } + + try zld.file.pwriteAll(buffer.items, sect.offset); +} +const EhFrameRecordTag = enum { cie, fde }; + +pub fn EhFrameRecord(comptime is_mutable: bool) type { + return struct { + tag: EhFrameRecordTag, + size: u32, + data: if (is_mutable) []u8 else []const u8, + + const Record = @This(); + + pub fn deinit(rec: *Record, gpa: Allocator) void { + comptime assert(is_mutable); + gpa.free(rec.data); + } + + pub fn toOwned(rec: Record, gpa: Allocator) Allocator.Error!EhFrameRecord(true) { + const data = try gpa.dupe(u8, rec.data); + return EhFrameRecord(true){ + .tag = rec.tag, + .size = rec.size, + .data = data, + }; + } + + pub inline fn getSize(rec: Record) u32 { + return 4 + rec.size; + } + + pub fn scanRelocs( + rec: Record, + zld: *Zld, + object_id: u32, + source_offset: u32, + ) !void { + if (rec.getPersonalityPointerReloc(zld, object_id, source_offset)) |target| { + try Atom.addGotEntry(zld, target); + } + } + + pub fn getTargetSymbolAddress(rec: Record, ctx: struct { + base_addr: u64, + base_offset: u64, + }) u64 { + assert(rec.tag == .fde); + const addend = mem.readIntLittle(i64, rec.data[4..][0..8]); + return @intCast(u64, @intCast(i64, ctx.base_addr + ctx.base_offset + 8) + addend); + } + + pub fn setTargetSymbolAddress(rec: *Record, value: u64, ctx: struct { + base_addr: u64, + base_offset: u64, + }) !void { + assert(rec.tag == .fde); + const addend = @intCast(i64, value) - @intCast(i64, ctx.base_addr + ctx.base_offset + 8); + mem.writeIntLittle(i64, rec.data[4..][0..8], addend); + } + + pub fn getPersonalityPointerReloc( + rec: Record, + zld: *Zld, + object_id: u32, + source_offset: u32, + ) ?SymbolWithLoc { + const cpu_arch = zld.options.target.cpu.arch; + const relocs = getRelocs(zld, object_id, source_offset); + for (relocs) |rel| { + switch (cpu_arch) { + .aarch64 => { + const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type); + switch (rel_type) { + .ARM64_RELOC_SUBTRACTOR, + .ARM64_RELOC_UNSIGNED, + => continue, + .ARM64_RELOC_POINTER_TO_GOT => {}, + else => unreachable, + } + }, + .x86_64 => { + const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type); + switch (rel_type) { + .X86_64_RELOC_GOT => {}, + else => unreachable, + } + }, + else => unreachable, + } + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + rec.data, + @intCast(i32, source_offset) + 4, + ); + return target; + } + return null; + } + + pub fn relocate(rec: *Record, zld: *Zld, object_id: u32, ctx: struct { + source_offset: u32, + out_offset: u32, + sect_addr: u64, + }) !void { + comptime assert(is_mutable); + + const cpu_arch = zld.options.target.cpu.arch; + const relocs = getRelocs(zld, object_id, ctx.source_offset); + + for (relocs) |rel| { + const target = UnwindInfo.parseRelocTarget( + zld, + object_id, + rel, + rec.data, + @intCast(i32, ctx.source_offset) + 4, + ); + const rel_offset = @intCast(u32, rel.r_address - @intCast(i32, ctx.source_offset) - 4); + const source_addr = ctx.sect_addr + rel_offset + ctx.out_offset + 4; + + switch (cpu_arch) { + .aarch64 => { + const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type); + switch (rel_type) { + .ARM64_RELOC_SUBTRACTOR => { + // Address of the __eh_frame in the source object file + }, + .ARM64_RELOC_POINTER_TO_GOT => { + const target_addr = try Atom.getRelocTargetAddress(zld, target, true, false); + const result = math.cast(i32, @intCast(i64, target_addr) - @intCast(i64, source_addr)) orelse + return error.Overflow; + mem.writeIntLittle(i32, rec.data[rel_offset..][0..4], result); + }, + .ARM64_RELOC_UNSIGNED => { + assert(rel.r_extern == 1); + const target_addr = try Atom.getRelocTargetAddress(zld, target, false, false); + const result = @intCast(i64, target_addr) - @intCast(i64, source_addr); + mem.writeIntLittle(i64, rec.data[rel_offset..][0..8], @intCast(i64, result)); + }, + else => unreachable, + } + }, + .x86_64 => { + const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type); + switch (rel_type) { + .X86_64_RELOC_GOT => { + const target_addr = try Atom.getRelocTargetAddress(zld, target, true, false); + const addend = mem.readIntLittle(i32, rec.data[rel_offset..][0..4]); + const adjusted_target_addr = @intCast(u64, @intCast(i64, target_addr) + addend); + const disp = try Atom.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0); + mem.writeIntLittle(i32, rec.data[rel_offset..][0..4], disp); + }, + else => unreachable, + } + }, + else => unreachable, + } + } + } + + pub fn getCiePointer(rec: Record) u32 { + assert(rec.tag == .fde); + return mem.readIntLittle(u32, rec.data[0..4]); + } + + pub fn setCiePointer(rec: *Record, ptr: u32) void { + assert(rec.tag == .fde); + mem.writeIntLittle(u32, rec.data[0..4], ptr); + } + + pub fn getAugmentationString(rec: Record) []const u8 { + assert(rec.tag == .cie); + return mem.sliceTo(@ptrCast([*:0]const u8, rec.data.ptr + 5), 0); + } + + pub fn getPersonalityPointer(rec: Record, ctx: struct { + base_addr: u64, + base_offset: u64, + }) !?u64 { + assert(rec.tag == .cie); + const aug_str = rec.getAugmentationString(); + + var stream = std.io.fixedBufferStream(rec.data[9 + aug_str.len ..]); + var creader = std.io.countingReader(stream.reader()); + const reader = creader.reader(); + + for (aug_str) |ch, i| switch (ch) { + 'z' => if (i > 0) { + return error.BadDwarfCfi; + } else { + _ = try leb.readULEB128(u64, reader); + }, + 'R' => { + _ = try reader.readByte(); + }, + 'P' => { + const enc = try reader.readByte(); + const offset = ctx.base_offset + 13 + aug_str.len + creader.bytes_read; + const ptr = try getEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), reader); + return ptr; + }, + 'L' => { + _ = try reader.readByte(); + }, + 'S', 'B', 'G' => {}, + else => return error.BadDwarfCfi, + }; + + return null; + } + + pub fn getLsdaPointer(rec: Record, cie: Record, ctx: struct { + base_addr: u64, + base_offset: u64, + }) !?u64 { + assert(rec.tag == .fde); + const enc = (try cie.getLsdaEncoding()) orelse return null; + var stream = std.io.fixedBufferStream(rec.data[20..]); + const reader = stream.reader(); + _ = try reader.readByte(); + const offset = ctx.base_offset + 25; + const ptr = try getEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), reader); + return ptr; + } + + pub fn setLsdaPointer(rec: *Record, cie: Record, value: u64, ctx: struct { + base_addr: u64, + base_offset: u64, + }) !void { + assert(rec.tag == .fde); + const enc = (try cie.getLsdaEncoding()) orelse unreachable; + var stream = std.io.fixedBufferStream(rec.data[21..]); + const writer = stream.writer(); + const offset = ctx.base_offset + 25; + try setEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), value, writer); + } + + fn getLsdaEncoding(rec: Record) !?u8 { + assert(rec.tag == .cie); + const aug_str = rec.getAugmentationString(); + + const base_offset = 9 + aug_str.len; + var stream = std.io.fixedBufferStream(rec.data[base_offset..]); + var creader = std.io.countingReader(stream.reader()); + const reader = creader.reader(); + + for (aug_str) |ch, i| switch (ch) { + 'z' => if (i > 0) { + return error.BadDwarfCfi; + } else { + _ = try leb.readULEB128(u64, reader); + }, + 'R' => { + _ = try reader.readByte(); + }, + 'P' => { + const enc = try reader.readByte(); + _ = try getEncodedPointer(enc, 0, reader); + }, + 'L' => { + const enc = try reader.readByte(); + return enc; + }, + 'S', 'B', 'G' => {}, + else => return error.BadDwarfCfi, + }; + + return null; + } + + fn getEncodedPointer(enc: u8, pcrel_offset: i64, reader: anytype) !?u64 { + if (enc == EH_PE.omit) return null; + + var ptr: i64 = switch (enc & 0x0F) { + EH_PE.absptr => @bitCast(i64, try reader.readIntLittle(u64)), + EH_PE.udata2 => @bitCast(i16, try reader.readIntLittle(u16)), + EH_PE.udata4 => @bitCast(i32, try reader.readIntLittle(u32)), + EH_PE.udata8 => @bitCast(i64, try reader.readIntLittle(u64)), + EH_PE.uleb128 => @bitCast(i64, try leb.readULEB128(u64, reader)), + EH_PE.sdata2 => try reader.readIntLittle(i16), + EH_PE.sdata4 => try reader.readIntLittle(i32), + EH_PE.sdata8 => try reader.readIntLittle(i64), + EH_PE.sleb128 => try leb.readILEB128(i64, reader), + else => return null, + }; + + switch (enc & 0x70) { + EH_PE.absptr => {}, + EH_PE.pcrel => ptr += pcrel_offset, + EH_PE.datarel, + EH_PE.textrel, + EH_PE.funcrel, + EH_PE.aligned, + => return null, + else => return null, + } + + return @bitCast(u64, ptr); + } + + fn setEncodedPointer(enc: u8, pcrel_offset: i64, value: u64, writer: anytype) !void { + if (enc == EH_PE.omit) return; + + var actual = @intCast(i64, value); + + switch (enc & 0x70) { + EH_PE.absptr => {}, + EH_PE.pcrel => actual -= pcrel_offset, + EH_PE.datarel, + EH_PE.textrel, + EH_PE.funcrel, + EH_PE.aligned, + => unreachable, + else => unreachable, + } + + switch (enc & 0x0F) { + EH_PE.absptr => try writer.writeIntLittle(u64, @bitCast(u64, actual)), + EH_PE.udata2 => try writer.writeIntLittle(u16, @bitCast(u16, @intCast(i16, actual))), + EH_PE.udata4 => try writer.writeIntLittle(u32, @bitCast(u32, @intCast(i32, actual))), + EH_PE.udata8 => try writer.writeIntLittle(u64, @bitCast(u64, actual)), + EH_PE.uleb128 => try leb.writeULEB128(writer, @bitCast(u64, actual)), + EH_PE.sdata2 => try writer.writeIntLittle(i16, @intCast(i16, actual)), + EH_PE.sdata4 => try writer.writeIntLittle(i32, @intCast(i32, actual)), + EH_PE.sdata8 => try writer.writeIntLittle(i64, actual), + EH_PE.sleb128 => try leb.writeILEB128(writer, actual), + else => unreachable, + } + } + }; +} + +pub fn getRelocs( + zld: *Zld, + object_id: u32, + source_offset: u32, +) []align(1) const macho.relocation_info { + const object = &zld.objects.items[object_id]; + assert(object.hasEhFrameRecords()); + const urel = object.eh_frame_relocs_lookup.get(source_offset) orelse + return &[0]macho.relocation_info{}; + const all_relocs = object.getRelocs(object.eh_frame_sect.?); + return all_relocs[urel.reloc.start..][0..urel.reloc.len]; +} + +pub const Iterator = struct { + data: []const u8, + pos: u32 = 0, + + pub fn next(it: *Iterator) !?EhFrameRecord(false) { + if (it.pos >= it.data.len) return null; + + var stream = std.io.fixedBufferStream(it.data[it.pos..]); + const reader = stream.reader(); + + var size = try reader.readIntLittle(u32); + if (size == 0xFFFFFFFF) { + log.err("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{}); + return error.BadDwarfCfi; + } + + const id = try reader.readIntLittle(u32); + const tag: EhFrameRecordTag = if (id == 0) .cie else .fde; + const offset: u32 = 4; + const record = EhFrameRecord(false){ + .tag = tag, + .size = size, + .data = it.data[it.pos + offset ..][0..size], + }; + + it.pos += size + offset; + + return record; + } + + pub fn reset(it: *Iterator) void { + it.pos = 0; + } + + pub fn seekTo(it: *Iterator, pos: u32) void { + assert(pos >= 0 and pos < it.data.len); + it.pos = pos; + } +}; + +pub const EH_PE = struct { + pub const absptr = 0x00; + pub const uleb128 = 0x01; + pub const udata2 = 0x02; + pub const udata4 = 0x03; + pub const udata8 = 0x04; + pub const sleb128 = 0x09; + pub const sdata2 = 0x0A; + pub const sdata4 = 0x0B; + pub const sdata8 = 0x0C; + pub const pcrel = 0x10; + pub const textrel = 0x20; + pub const datarel = 0x30; + pub const funcrel = 0x40; + pub const aligned = 0x50; + pub const indirect = 0x80; + pub const omit = 0xFF; +}; diff --git a/src/link/MachO/thunks.zig b/src/link/MachO/thunks.zig index db85884c31..f12fb80668 100644 --- a/src/link/MachO/thunks.zig +++ b/src/link/MachO/thunks.zig @@ -68,7 +68,7 @@ pub const Thunk = struct { } }; -pub fn createThunks(zld: *Zld, sect_id: u8, reverse_lookups: [][]u32) !void { +pub fn createThunks(zld: *Zld, sect_id: u8) !void { const header = &zld.sections.items(.header)[sect_id]; if (header.size == 0) return; @@ -140,7 +140,6 @@ pub fn createThunks(zld: *Zld, sect_id: u8, reverse_lookups: [][]u32) !void { try scanRelocs( zld, atom_index, - reverse_lookups[atom.getFile().?], allocated, thunk_index, group_end, @@ -214,7 +213,6 @@ fn allocateThunk( fn scanRelocs( zld: *Zld, atom_index: AtomIndex, - reverse_lookup: []u32, allocated: std.AutoHashMap(AtomIndex, void), thunk_index: ThunkIndex, group_end: AtomIndex, @@ -231,7 +229,7 @@ fn scanRelocs( for (relocs) |rel| { if (!relocNeedsThunk(rel)) continue; - const target = Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup); + const target = Atom.parseRelocTarget(zld, atom_index, rel); if (isReachable(zld, atom_index, rel, base_offset, target, allocated)) continue; log.debug("{x}: source = {s}@{x}, target = {s}@{x} unreachable", .{ @@ -308,7 +306,8 @@ fn isReachable( if (!allocated.contains(target_atom_index)) return false; const source_addr = source_sym.n_value + @intCast(u32, rel.r_address - base_offset); - const target_addr = Atom.getRelocTargetAddress(zld, rel, target, false) catch unreachable; + const is_via_got = Atom.relocRequiresGot(zld, rel); + const target_addr = Atom.getRelocTargetAddress(zld, target, is_via_got, false) catch unreachable; _ = Atom.calcPcRelativeDisplacementArm64(source_addr, target_addr) catch return false; diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig index 9b3022f3e3..4cb346aa47 100644 --- a/src/link/MachO/zld.zig +++ b/src/link/MachO/zld.zig @@ -10,6 +10,7 @@ const mem = std.mem; const aarch64 = @import("../../arch/aarch64/bits.zig"); const dead_strip = @import("dead_strip.zig"); +const eh_frame = @import("eh_frame.zig"); const fat = @import("fat.zig"); const link = @import("../../link.zig"); const load_commands = @import("load_commands.zig"); @@ -30,6 +31,7 @@ const LibStub = @import("../tapi.zig").LibStub; const Object = @import("Object.zig"); const StringTable = @import("../strtab.zig").StringTable; const Trie = @import("Trie.zig"); +const UnwindInfo = @import("UnwindInfo.zig"); const Bind = @import("dyld_info/bind.zig").Bind(*const Zld, SymbolWithLoc); const LazyBind = @import("dyld_info/bind.zig").LazyBind(*const Zld, SymbolWithLoc); @@ -389,6 +391,14 @@ pub const Zld = struct { break :blk null; } + // We handle unwind info separately. + if (mem.eql(u8, "__TEXT", segname) and mem.eql(u8, "__eh_frame", sectname)) { + break :blk null; + } + if (mem.eql(u8, "__LD", segname) and mem.eql(u8, "__compact_unwind", sectname)) { + break :blk null; + } + if (sect.isCode()) { break :blk self.getSectionByName("__TEXT", "__text") orelse try self.initSection( "__TEXT", @@ -402,12 +412,6 @@ pub const Zld = struct { } if (sect.isDebug()) { - // TODO debug attributes - if (mem.eql(u8, "__LD", segname) and mem.eql(u8, "__compact_unwind", sectname)) { - log.debug("TODO compact unwind section: type 0x{x}, name '{s},{s}'", .{ - sect.flags, segname, sectname, - }); - } break :blk null; } @@ -459,13 +463,6 @@ pub const Zld = struct { ); }, macho.S_COALESCED => { - // TODO unwind info - if (mem.eql(u8, "__TEXT", segname) and mem.eql(u8, "__eh_frame", sectname)) { - log.debug("TODO eh frame section: type 0x{x}, name '{s},{s}'", .{ - sect.flags, segname, sectname, - }); - break :blk null; - } break :blk self.getSectionByName(segname, sectname) orelse try self.initSection( segname, sectname, @@ -937,7 +934,7 @@ pub const Zld = struct { } } - fn resolveSymbolsInObject(self: *Zld, object_id: u16, resolver: *SymbolResolver) !void { + fn resolveSymbolsInObject(self: *Zld, object_id: u32, resolver: *SymbolResolver) !void { const object = &self.objects.items[object_id]; const in_symtab = object.in_symtab orelse return; @@ -977,7 +974,7 @@ pub const Zld = struct { continue; } - const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id }; + const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id + 1 }; const global_index = resolver.table.get(sym_name) orelse { const gpa = self.gpa; @@ -1378,7 +1375,7 @@ pub const Zld = struct { } } - fn writeAtoms(self: *Zld, reverse_lookups: [][]u32) !void { + fn writeAtoms(self: *Zld) !void { const gpa = self.gpa; const slice = self.sections.slice(); @@ -1386,6 +1383,7 @@ pub const Zld = struct { const header = slice.items(.header)[sect_id]; var atom_index = first_atom_index; + if (atom_index == 0) continue; if (header.isZerofill()) continue; var buffer = std.ArrayList(u8).init(gpa); @@ -1407,7 +1405,7 @@ pub const Zld = struct { log.debug(" (adding ATOM(%{d}, '{s}') from object({?}) to buffer)", .{ atom.sym_index, self.getSymbolName(atom.getSymbolWithLoc()), - atom.file, + atom.getFile(), }); if (padding_size > 0) { log.debug(" (with padding {x})", .{padding_size}); @@ -1460,7 +1458,6 @@ pub const Zld = struct { atom_index, buffer.items[offset..][0..size], relocs, - reverse_lookups[atom.getFile().?], ); } @@ -1501,9 +1498,10 @@ pub const Zld = struct { while (i < slice.len) : (i += 1) { const section = self.sections.get(i); if (section.header.size == 0) { - log.debug("pruning section {s},{s}", .{ + log.debug("pruning section {s},{s} {d}", .{ section.header.segName(), section.header.sectName(), + section.first_atom_index, }); continue; } @@ -1519,7 +1517,7 @@ pub const Zld = struct { } } - fn calcSectionSizes(self: *Zld, reverse_lookups: [][]u32) !void { + fn calcSectionSizes(self: *Zld) !void { const slice = self.sections.slice(); for (slice.items(.header)) |*header, sect_id| { if (header.size == 0) continue; @@ -1528,6 +1526,8 @@ pub const Zld = struct { } var atom_index = slice.items(.first_atom_index)[sect_id]; + if (atom_index == 0) continue; + header.size = 0; header.@"align" = 0; @@ -1556,7 +1556,7 @@ pub const Zld = struct { if (mem.eql(u8, header.sectName(), "__stub_helper")) continue; // Create jump/branch range extenders if needed. - try thunks.createThunks(self, @intCast(u8, sect_id), reverse_lookups); + try thunks.createThunks(self, @intCast(u8, sect_id)); } } } @@ -1601,8 +1601,6 @@ pub const Zld = struct { const slice = self.sections.slice(); for (slice.items(.header)[indexes.start..indexes.end]) |*header, sect_id| { - var atom_index = slice.items(.first_atom_index)[indexes.start + sect_id]; - const alignment = try math.powi(u32, 2, header.@"align"); const start_aligned = mem.alignForwardGeneric(u64, start, alignment); const n_sect = @intCast(u8, indexes.start + sect_id + 1); @@ -1613,48 +1611,51 @@ pub const Zld = struct { @intCast(u32, segment.fileoff + start_aligned); header.addr = segment.vmaddr + start_aligned; - log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{ - n_sect, - header.segName(), - header.sectName(), - }); + var atom_index = slice.items(.first_atom_index)[indexes.start + sect_id]; + if (atom_index > 0) { + log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{ + n_sect, + header.segName(), + header.sectName(), + }); - while (true) { - const atom = self.getAtom(atom_index); - const sym = self.getSymbolPtr(atom.getSymbolWithLoc()); - sym.n_value += header.addr; - sym.n_sect = n_sect; + while (true) { + const atom = self.getAtom(atom_index); + const sym = self.getSymbolPtr(atom.getSymbolWithLoc()); + sym.n_value += header.addr; + sym.n_sect = n_sect; - log.debug(" ATOM(%{d}, '{s}') @{x}", .{ - atom.sym_index, - self.getSymbolName(atom.getSymbolWithLoc()), - sym.n_value, - }); + log.debug(" ATOM(%{d}, '{s}') @{x}", .{ + atom.sym_index, + self.getSymbolName(atom.getSymbolWithLoc()), + sym.n_value, + }); - if (atom.getFile() != null) { - // Update each symbol contained within the atom - var it = Atom.getInnerSymbolsIterator(self, atom_index); - while (it.next()) |sym_loc| { - const inner_sym = self.getSymbolPtr(sym_loc); - inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset( - self, - atom_index, - sym_loc.sym_index, - ); - inner_sym.n_sect = n_sect; - } + if (atom.getFile() != null) { + // Update each symbol contained within the atom + var it = Atom.getInnerSymbolsIterator(self, atom_index); + while (it.next()) |sym_loc| { + const inner_sym = self.getSymbolPtr(sym_loc); + inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset( + self, + atom_index, + sym_loc.sym_index, + ); + inner_sym.n_sect = n_sect; + } - // If there is a section alias, update it now too - if (Atom.getSectionAlias(self, atom_index)) |sym_loc| { - const alias = self.getSymbolPtr(sym_loc); - alias.n_value = sym.n_value; - alias.n_sect = n_sect; + // If there is a section alias, update it now too + if (Atom.getSectionAlias(self, atom_index)) |sym_loc| { + const alias = self.getSymbolPtr(sym_loc); + alias.n_value = sym.n_value; + alias.n_sect = n_sect; + } } - } - if (atom.next_index) |next_index| { - atom_index = next_index; - } else break; + if (atom.next_index) |next_index| { + atom_index = next_index; + } else break; + } } start = start_aligned + header.size; @@ -1675,7 +1676,7 @@ pub const Zld = struct { reserved2: u32 = 0, }; - fn initSection( + pub fn initSection( self: *Zld, segname: []const u8, sectname: []const u8, @@ -1685,7 +1686,7 @@ pub const Zld = struct { log.debug("creating section '{s},{s}'", .{ segname, sectname }); const index = @intCast(u8, self.sections.slice().len); try self.sections.append(gpa, .{ - .segment_index = undefined, + .segment_index = undefined, // Segments will be created automatically later down the pipeline .header = .{ .sectname = makeStaticString(sectname), .segname = makeStaticString(segname), @@ -1693,13 +1694,13 @@ pub const Zld = struct { .reserved1 = opts.reserved1, .reserved2 = opts.reserved2, }, - .first_atom_index = undefined, - .last_atom_index = undefined, + .first_atom_index = 0, + .last_atom_index = 0, }); return index; } - inline fn getSegmentPrecedence(segname: []const u8) u4 { + fn getSegmentPrecedence(segname: []const u8) u4 { if (mem.eql(u8, segname, "__PAGEZERO")) return 0x0; if (mem.eql(u8, segname, "__TEXT")) return 0x1; if (mem.eql(u8, segname, "__DATA_CONST")) return 0x2; @@ -1708,14 +1709,14 @@ pub const Zld = struct { return 0x4; } - inline fn getSegmentMemoryProtection(segname: []const u8) macho.vm_prot_t { + fn getSegmentMemoryProtection(segname: []const u8) macho.vm_prot_t { if (mem.eql(u8, segname, "__PAGEZERO")) return macho.PROT.NONE; if (mem.eql(u8, segname, "__TEXT")) return macho.PROT.READ | macho.PROT.EXEC; if (mem.eql(u8, segname, "__LINKEDIT")) return macho.PROT.READ; return macho.PROT.READ | macho.PROT.WRITE; } - inline fn getSectionPrecedence(header: macho.section_64) u8 { + fn getSectionPrecedence(header: macho.section_64) u8 { const segment_precedence: u4 = getSegmentPrecedence(header.segName()); const section_precedence: u4 = blk: { if (header.isCode()) { @@ -1732,10 +1733,11 @@ pub const Zld = struct { macho.S_ZEROFILL => break :blk 0xf, macho.S_THREAD_LOCAL_REGULAR => break :blk 0xd, macho.S_THREAD_LOCAL_ZEROFILL => break :blk 0xe, - else => if (mem.eql(u8, "__eh_frame", header.sectName())) - break :blk 0xf - else - break :blk 0x3, + else => { + if (mem.eql(u8, "__unwind_info", header.sectName())) break :blk 0xe; + if (mem.eql(u8, "__eh_frame", header.sectName())) break :blk 0xf; + break :blk 0x3; + }, } }; return (@intCast(u8, segment_precedence) << 4) + section_precedence; @@ -1768,8 +1770,8 @@ pub const Zld = struct { } } - fn writeLinkeditSegmentData(self: *Zld, reverse_lookups: [][]u32) !void { - try self.writeDyldInfoData(reverse_lookups); + fn writeLinkeditSegmentData(self: *Zld) !void { + try self.writeDyldInfoData(); try self.writeFunctionStarts(); try self.writeDataInCode(); try self.writeSymtabs(); @@ -1806,7 +1808,7 @@ pub const Zld = struct { } } - fn collectRebaseData(self: *Zld, rebase: *Rebase, reverse_lookups: [][]u32) !void { + fn collectRebaseData(self: *Zld, rebase: *Rebase) !void { log.debug("collecting rebase data", .{}); // First, unpack GOT entries @@ -1862,6 +1864,7 @@ pub const Zld = struct { const cpu_arch = self.options.target.cpu.arch; var atom_index = slice.items(.first_atom_index)[sect_id]; + if (atom_index == 0) continue; while (true) { const atom = self.getAtom(atom_index); @@ -1899,7 +1902,7 @@ pub const Zld = struct { }, else => unreachable, } - const target = Atom.parseRelocTarget(self, atom_index, rel, reverse_lookups[atom.getFile().?]); + const target = Atom.parseRelocTarget(self, atom_index, rel); const target_sym = self.getSymbol(target); if (target_sym.undf()) continue; @@ -1962,7 +1965,10 @@ pub const Zld = struct { } } - fn collectBindData(self: *Zld, bind: *Bind, reverse_lookups: [][]u32) !void { + fn collectBindData( + self: *Zld, + bind: *Bind, + ) !void { log.debug("collecting bind data", .{}); // First, unpack GOT section @@ -1993,6 +1999,7 @@ pub const Zld = struct { const cpu_arch = self.options.target.cpu.arch; var atom_index = slice.items(.first_atom_index)[sect_id]; + if (atom_index == 0) continue; log.debug("{s},{s}", .{ header.segName(), header.sectName() }); @@ -2033,7 +2040,7 @@ pub const Zld = struct { else => unreachable, } - const global = Atom.parseRelocTarget(self, atom_index, rel, reverse_lookups[atom.getFile().?]); + const global = Atom.parseRelocTarget(self, atom_index, rel); const bind_sym_name = self.getSymbolName(global); const bind_sym = self.getSymbol(global); if (!bind_sym.undf()) continue; @@ -2164,16 +2171,18 @@ pub const Zld = struct { try trie.finalize(gpa); } - fn writeDyldInfoData(self: *Zld, reverse_lookups: [][]u32) !void { + fn writeDyldInfoData( + self: *Zld, + ) !void { const gpa = self.gpa; var rebase = Rebase{}; defer rebase.deinit(gpa); - try self.collectRebaseData(&rebase, reverse_lookups); + try self.collectRebaseData(&rebase); var bind = Bind{}; defer bind.deinit(gpa); - try self.collectBindData(&bind, reverse_lookups); + try self.collectBindData(&bind); var lazy_bind = LazyBind{}; defer lazy_bind.deinit(gpa); @@ -2873,12 +2882,12 @@ pub const Zld = struct { return buf; } - pub inline fn getAtomPtr(self: *Zld, atom_index: AtomIndex) *Atom { + pub fn getAtomPtr(self: *Zld, atom_index: AtomIndex) *Atom { assert(atom_index < self.atoms.items.len); return &self.atoms.items[atom_index]; } - pub inline fn getAtom(self: Zld, atom_index: AtomIndex) Atom { + pub fn getAtom(self: Zld, atom_index: AtomIndex) Atom { assert(atom_index < self.atoms.items.len); return self.atoms.items[atom_index]; } @@ -2889,17 +2898,17 @@ pub const Zld = struct { } else return null; } - pub inline fn getSegment(self: Zld, sect_id: u8) macho.segment_command_64 { + pub fn getSegment(self: Zld, sect_id: u8) macho.segment_command_64 { const index = self.sections.items(.segment_index)[sect_id]; return self.segments.items[index]; } - pub inline fn getSegmentPtr(self: *Zld, sect_id: u8) *macho.segment_command_64 { + pub fn getSegmentPtr(self: *Zld, sect_id: u8) *macho.segment_command_64 { const index = self.sections.items(.segment_index)[sect_id]; return &self.segments.items[index]; } - pub inline fn getLinkeditSegmentPtr(self: *Zld) *macho.segment_command_64 { + pub fn getLinkeditSegmentPtr(self: *Zld) *macho.segment_command_64 { assert(self.segments.items.len > 0); const seg = &self.segments.items[self.segments.items.len - 1]; assert(mem.eql(u8, seg.segName(), "__LINKEDIT")); @@ -3384,6 +3393,8 @@ pub const Zld = struct { const slice = self.sections.slice(); for (slice.items(.first_atom_index)) |first_atom_index, sect_id| { var atom_index = first_atom_index; + if (atom_index == 0) continue; + const header = slice.items(.header)[sect_id]; log.debug("{s},{s}", .{ header.segName(), header.sectName() }); @@ -3412,7 +3423,7 @@ pub const Zld = struct { sym.n_value, atom.size, atom.alignment, - atom.file, + atom.getFile(), sym.n_sect, }); @@ -3475,19 +3486,19 @@ const IndirectPointer = struct { } }; -pub const SymbolWithLoc = struct { +pub const SymbolWithLoc = extern struct { // Index into the respective symbol table. sym_index: u32, - // -1 means it's a synthetic global. - file: i32 = -1, + // 0 means it's a synthetic global. + file: u32 = 0, - pub inline fn getFile(self: SymbolWithLoc) ?u31 { - if (self.file == -1) return null; - return @intCast(u31, self.file); + pub fn getFile(self: SymbolWithLoc) ?u32 { + if (self.file == 0) return null; + return self.file - 1; } - pub inline fn eql(self: SymbolWithLoc, other: SymbolWithLoc) bool { + pub fn eql(self: SymbolWithLoc, other: SymbolWithLoc) bool { return self.file == other.file and self.sym_index == other.sym_index; } }; @@ -3965,7 +3976,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr }; for (zld.objects.items) |_, object_id| { - try zld.resolveSymbolsInObject(@intCast(u16, object_id), &resolver); + try zld.resolveSymbolsInObject(@intCast(u32, object_id), &resolver); } try zld.resolveSymbolsInArchives(&resolver); @@ -3995,16 +4006,11 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr } for (zld.objects.items) |*object, object_id| { - try object.splitIntoAtoms(&zld, @intCast(u31, object_id)); - } - - var reverse_lookups: [][]u32 = try arena.alloc([]u32, zld.objects.items.len); - for (zld.objects.items) |object, i| { - reverse_lookups[i] = try object.createReverseSymbolLookup(arena); + try object.splitIntoAtoms(&zld, @intCast(u32, object_id)); } if (gc_sections) { - try dead_strip.gcAtoms(&zld, reverse_lookups); + try dead_strip.gcAtoms(&zld); } try zld.createDyldPrivateAtom(); @@ -4019,13 +4025,24 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr if (header.isZerofill()) continue; const relocs = Atom.getAtomRelocs(&zld, atom_index); - try Atom.scanAtomRelocs(&zld, atom_index, relocs, reverse_lookups[atom.getFile().?]); + try Atom.scanAtomRelocs(&zld, atom_index, relocs); } } + try eh_frame.scanRelocs(&zld); + try UnwindInfo.scanRelocs(&zld); + try zld.createDyldStubBinderGotAtom(); - try zld.calcSectionSizes(reverse_lookups); + try zld.calcSectionSizes(); + + var unwind_info = UnwindInfo{ .gpa = zld.gpa }; + defer unwind_info.deinit(); + try unwind_info.collect(&zld); + + try eh_frame.calcSectionSize(&zld, &unwind_info); + try unwind_info.calcSectionSize(&zld); + try zld.pruneAndSortSections(); try zld.createSegments(); try zld.allocateSegments(); @@ -4039,8 +4056,10 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr zld.logAtoms(); } - try zld.writeAtoms(reverse_lookups); - try zld.writeLinkeditSegmentData(reverse_lookups); + try zld.writeAtoms(); + try eh_frame.write(&zld, &unwind_info); + try unwind_info.write(&zld); + try zld.writeLinkeditSegmentData(); // If the last section of __DATA segment is zerofill section, we need to ensure // that the free space between the end of the last non-zerofill section of __DATA diff --git a/src/type.zig b/src/type.zig index 65391aabfc..c675cd225d 100644 --- a/src/type.zig +++ b/src/type.zig @@ -3789,6 +3789,39 @@ pub const Type = extern union { } } + /// Returns true if the type's layout is already resolved and it is safe + /// to use `abiSize`, `abiAlignment` and `bitSize` on it. + pub fn layoutIsResolved(ty: Type) bool { + switch (ty.zigTypeTag()) { + .Struct => { + if (ty.castTag(.@"struct")) |struct_ty| { + return struct_ty.data.haveLayout(); + } + return true; + }, + .Union => { + if (ty.cast(Payload.Union)) |union_ty| { + return union_ty.data.haveLayout(); + } + return true; + }, + .Array => { + if (ty.arrayLenIncludingSentinel() == 0) return true; + return ty.childType().layoutIsResolved(); + }, + .Optional => { + var buf: Type.Payload.ElemType = undefined; + const payload_ty = ty.optionalChild(&buf); + return payload_ty.layoutIsResolved(); + }, + .ErrorUnion => { + const payload_ty = ty.errorUnionPayload(); + return payload_ty.layoutIsResolved(); + }, + else => return true, + } + } + pub fn isSinglePointer(self: Type) bool { return switch (self.tag()) { .single_const_pointer, @@ -5500,7 +5533,7 @@ pub const Type = extern union { } const S = struct { fn fieldWithRange(int_ty: Type, int_val: Value, end: usize, m: *Module) ?usize { - if (int_val.compareAllWithZero(.lt)) return null; + if (int_val.compareAllWithZero(.lt, m)) return null; var end_payload: Value.Payload.U64 = .{ .base = .{ .tag = .int_u64 }, .data = end, @@ -6498,12 +6531,7 @@ pub const Type = extern union { // pointee type needs to be resolved more, that needs to be done before calling // this ptr() function. if (d.@"align" != 0) canonicalize: { - if (d.pointee_type.castTag(.@"struct")) |struct_ty| { - if (!struct_ty.data.haveLayout()) break :canonicalize; - } - if (d.pointee_type.cast(Payload.Union)) |union_ty| { - if (!union_ty.data.haveLayout()) break :canonicalize; - } + if (!d.pointee_type.layoutIsResolved()) break :canonicalize; if (d.@"align" == d.pointee_type.abiAlignment(target)) { d.@"align" = 0; } @@ -6528,12 +6556,12 @@ pub const Type = extern union { if (!d.mutable and d.pointee_type.eql(Type.u8, mod)) { switch (d.size) { .Slice => { - if (sent.compareAllWithZero(.eq)) { + if (sent.compareAllWithZero(.eq, mod)) { return Type.initTag(.const_slice_u8_sentinel_0); } }, .Many => { - if (sent.compareAllWithZero(.eq)) { + if (sent.compareAllWithZero(.eq, mod)) { return Type.initTag(.manyptr_const_u8_sentinel_0); } }, diff --git a/src/value.zig b/src/value.zig index 5d38bcb7a9..306e31c0a7 100644 --- a/src/value.zig +++ b/src/value.zig @@ -2076,13 +2076,22 @@ pub const Value = extern union { /// For vectors, returns true if comparison is true for ALL elements. /// /// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)` - pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator) bool { - return compareAllWithZeroAdvanced(lhs, op, null) catch unreachable; + pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, mod: *Module) bool { + return compareAllWithZeroAdvancedExtra(lhs, op, mod, null) catch unreachable; } pub fn compareAllWithZeroAdvanced( lhs: Value, op: std.math.CompareOperator, + sema: *Sema, + ) Module.CompileError!bool { + return compareAllWithZeroAdvancedExtra(lhs, op, sema.mod, sema); + } + + pub fn compareAllWithZeroAdvancedExtra( + lhs: Value, + op: std.math.CompareOperator, + mod: *Module, opt_sema: ?*Sema, ) Module.CompileError!bool { if (lhs.isInf()) { @@ -2095,10 +2104,25 @@ pub const Value = extern union { } switch (lhs.tag()) { - .repeated => return lhs.castTag(.repeated).?.data.compareAllWithZeroAdvanced(op, opt_sema), + .repeated => return lhs.castTag(.repeated).?.data.compareAllWithZeroAdvancedExtra(op, mod, opt_sema), .aggregate => { for (lhs.castTag(.aggregate).?.data) |elem_val| { - if (!(try elem_val.compareAllWithZeroAdvanced(op, opt_sema))) return false; + if (!(try elem_val.compareAllWithZeroAdvancedExtra(op, mod, opt_sema))) return false; + } + return true; + }, + .str_lit => { + const str_lit = lhs.castTag(.str_lit).?.data; + const bytes = mod.string_literal_bytes.items[str_lit.index..][0..str_lit.len]; + for (bytes) |byte| { + if (!std.math.compare(byte, op, 0)) return false; + } + return true; + }, + .bytes => { + const bytes = lhs.castTag(.bytes).?.data; + for (bytes) |byte| { + if (!std.math.compare(byte, op, 0)) return false; } return true; }, @@ -3103,7 +3127,7 @@ pub const Value = extern union { .int_i64, .int_big_positive, .int_big_negative, - => compareAllWithZero(self, .eq), + => self.orderAgainstZero().compare(.eq), .undef => unreachable, .unreachable_value => unreachable, |