Merge branch 'ziglang:master' into some-documentation-updates-0

1 files changed, 53 insertions, 55 deletions

diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 6341f7e3d2..ad2d1b580f 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -878,7 +878,7 @@ pub fn generate(
     src_loc: Zcu.LazySrcLoc,
     func_index: InternPool.Index,
     air: *const Air,
-    liveness: *const Air.Liveness,
+    liveness: *const ?Air.Liveness,
 ) codegen.CodeGenError!Mir {
     _ = bin_file;
     const zcu = pt.zcu;
@@ -894,7 +894,7 @@ pub fn generate(
         .gpa = gpa,
         .pt = pt,
         .air = air.*,
-        .liveness = liveness.*,
+        .liveness = liveness.*.?,
         .target = &mod.resolved_target.result,
         .mod = mod,
         .owner = .{ .nav_index = func.owner_nav },
@@ -1103,11 +1103,7 @@ const FormatAirData = struct {
     inst: Air.Inst.Index,
 };
 fn formatAir(data: FormatAirData, w: *std.io.Writer) Writer.Error!void {
-    // not acceptable implementation because it ignores `w`:
-    //data.self.air.dumpInst(data.inst, data.self.pt, data.self.liveness);
-    _ = data;
-    _ = w;
-    @panic("TODO: unimplemented");
+    data.self.air.writeInst(w, data.inst, data.self.pt, data.self.liveness);
 }
 fn fmtAir(self: *CodeGen, inst: Air.Inst.Index) std.fmt.Formatter(FormatAirData, formatAir) {
     return .{ .data = .{ .self = self, .inst = inst } };
@@ -100674,11 +100670,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
-                try ops[0].toOffset(cg.fieldOffset(
+                try ops[0].toOffset(@intCast(codegen.fieldOffset(
                     cg.typeOf(struct_field.struct_operand),
                     ty_pl.ty.toType(),
                     struct_field.field_index,
-                ), cg);
+                    zcu,
+                )), cg);
                 try ops[0].finish(inst, &.{struct_field.struct_operand}, &ops, cg);
             },
             .struct_field_ptr_index_0,
@@ -100688,7 +100685,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
             => |air_tag| {
                 const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                 var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
-                try ops[0].toOffset(cg.fieldOffset(
+                try ops[0].toOffset(@intCast(codegen.fieldOffset(
                     cg.typeOf(ty_op.operand),
                     ty_op.ty.toType(),
                     switch (air_tag) {
@@ -100698,7 +100695,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .struct_field_ptr_index_2 => 2,
                         .struct_field_ptr_index_3 => 3,
                     },
-                ), cg);
+                    zcu,
+                )), cg);
                 try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
             },
             .struct_field_val => {
@@ -168108,11 +168106,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                 const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
                 var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr});
-                try ops[0].toOffset(-cg.fieldOffset(
+                try ops[0].toOffset(-@as(i32, @intCast(codegen.fieldOffset(
                     ty_pl.ty.toType(),
                     cg.typeOf(field_parent_ptr.field_ptr),
                     field_parent_ptr.field_index,
-                ), cg);
+                    zcu,
+                ))), cg);
                 try ops[0].finish(inst, &.{field_parent_ptr.field_ptr}, &ops, cg);
             },
             .wasm_memory_size, .wasm_memory_grow => unreachable,
@@ -168138,7 +168137,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
@@ -168162,7 +168161,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
@@ -168186,7 +168185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
@@ -174809,18 +174808,6 @@ fn airStore(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void {
     return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none });
 }
 
-fn fieldOffset(self: *CodeGen, ptr_agg_ty: Type, ptr_field_ty: Type, field_index: u32) i32 {
-    const pt = self.pt;
-    const zcu = pt.zcu;
-    const agg_ty = ptr_agg_ty.childType(zcu);
-    return switch (agg_ty.containerLayout(zcu)) {
-        .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(field_index, zcu)),
-        .@"packed" => @divExact(@as(i32, ptr_agg_ty.ptrInfo(zcu).packed_offset.bit_offset) +
-            (if (zcu.typeToStruct(agg_ty)) |loaded_struct| pt.structPackedFieldBitOffset(loaded_struct, field_index) else 0) -
-            ptr_field_ty.ptrInfo(zcu).packed_offset.bit_offset, 8),
-    };
-}
-
 fn genUnOp(self: *CodeGen, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air: Air.Inst.Ref) !MCValue {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -179309,10 +179296,13 @@ fn lowerSwitchBr(
         } else undefined;
         const table_start: u31 = @intCast(cg.mir_table.items.len);
         {
-            const condition_index_reg = if (condition_index.isRegister())
-                condition_index.getReg().?
-            else
-                try cg.copyToTmpRegister(.usize, condition_index);
+            const condition_index_reg = condition_index_reg: {
+                if (condition_index.isRegister()) {
+                    const condition_index_reg = condition_index.getReg().?;
+                    if (condition_index_reg.isClass(.general_purpose)) break :condition_index_reg condition_index_reg;
+                }
+                break :condition_index_reg try cg.copyToTmpRegister(.usize, condition_index);
+            };
             const condition_index_lock = cg.register_manager.lockReg(condition_index_reg);
             defer if (condition_index_lock) |lock| cg.register_manager.unlockReg(lock);
             try cg.truncateRegister(condition_ty, condition_index_reg);
@@ -184575,7 +184565,7 @@ fn airAggregateInit(self: *CodeGen, inst: Air.Inst.Index) !void {
                         }
                         const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
                         const elem_abi_bits = elem_abi_size * 8;
-                        const elem_off = pt.structPackedFieldBitOffset(loaded_struct, elem_i);
+                        const elem_off = zcu.structPackedFieldBitOffset(loaded_struct, elem_i);
                         const elem_byte_off: i32 = @intCast(elem_off / elem_abi_bits * elem_abi_size);
                         const elem_bit_off = elem_off % elem_abi_bits;
                         const elem_mcv = try self.resolveInst(elem);
@@ -185625,21 +185615,19 @@ fn resolveCallingConventionValues(
 fn fail(cg: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
     const zcu = cg.pt.zcu;
-    switch (cg.owner) {
-        .nav_index => |i| return zcu.codegenFail(i, format, args),
-        .lazy_sym => |s| return zcu.codegenFailType(s.ty, format, args),
-    }
-    return error.CodegenFail;
+    return switch (cg.owner) {
+        .nav_index => |i| zcu.codegenFail(i, format, args),
+        .lazy_sym => |s| zcu.codegenFailType(s.ty, format, args),
+    };
 }
 
 fn failMsg(cg: *CodeGen, msg: *Zcu.ErrorMsg) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
     const zcu = cg.pt.zcu;
-    switch (cg.owner) {
-        .nav_index => |i| return zcu.codegenFailMsg(i, msg),
-        .lazy_sym => |s| return zcu.codegenFailTypeMsg(s.ty, msg),
-    }
-    return error.CodegenFail;
+    return switch (cg.owner) {
+        .nav_index => |i| zcu.codegenFailMsg(i, msg),
+        .lazy_sym => |s| zcu.codegenFailTypeMsg(s.ty, msg),
+    };
 }
 
 fn parseRegName(name: []const u8) ?Register {
@@ -191932,18 +191920,15 @@ const Select = struct {
                 error.InvalidInstruction => {
                     const fixes = @tagName(mir_tag[0]);
                     const fixes_blank = std.mem.indexOfScalar(u8, fixes, '_').?;
-                    return s.cg.fail(
-                        "invalid instruction: '{s}{s}{s} {s} {s} {s} {s}'",
-                        .{
-                            fixes[0..fixes_blank],
-                            @tagName(mir_tag[1]),
-                            fixes[fixes_blank + 1 ..],
-                            @tagName(mir_ops[0]),
-                            @tagName(mir_ops[1]),
-                            @tagName(mir_ops[2]),
-                            @tagName(mir_ops[3]),
-                        },
-                    );
+                    return s.cg.fail("invalid instruction: '{s}{s}{s} {s} {s} {s} {s}'", .{
+                        fixes[0..fixes_blank],
+                        @tagName(mir_tag[1]),
+                        fixes[fixes_blank + 1 ..],
+                        @tagName(mir_ops[0]),
+                        @tagName(mir_ops[1]),
+                        @tagName(mir_ops[2]),
+                        @tagName(mir_ops[3]),
+                    });
                 },
                 else => |e| return e,
             };
@@ -194435,6 +194420,18 @@ fn select(
             while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {
                 if (try src_pattern.convert(src_temp, cg)) break;
             } else break;
+            var src_locks: [s_src_temps.len][2]?RegisterLock = @splat(@splat(null));
+            for (src_locks[0..src_temps.len], src_temps) |*locks, src_temp| {
+                const regs: [2]Register = switch (src_temp.tracking(cg).short) {
+                    else => continue,
+                    .register => |reg| .{ reg, .none },
+                    .register_pair => |regs| regs,
+                };
+                for (regs, locks) |reg, *lock| {
+                    if (reg == .none) continue;
+                    lock.* = cg.register_manager.lockRegIndex(RegisterManager.indexOfRegIntoTracked(reg) orelse continue);
+                }
+            }
             @memcpy(s_src_temps[0..src_temps.len], src_temps);
             std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
 
@@ -194453,6 +194450,7 @@ fn select(
             }
             assert(s.top == 0);
 
+            for (src_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
             for (tmp_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
             for (dst_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
             caller_preserved: {