Arrays elements failing trivial comparison associated with inlined for loop

[lassade]

Zig Version

0.12.0-dev.2341+92211135f

Steps to Reproduce and Observed Behavior

Just run the exe built using zig build-exe from code bellow:

const std = @import("std");

const App = struct {
    scroll_pos: [2]u32 = .{ 0, 0 },
    dirty: bool = false,

    fn scrollGood(self: *App, offset: [2]i32) void {
        const x = self.scroll_pos[0];
        const y = self.scroll_pos[1];

        inline for (0..2) |i| {
            if (offset[i] >= 0) {
                self.scroll_pos[i] +|= @bitCast(offset[i]);
            } else {
                self.scroll_pos[i] -|= @bitCast(-offset[i]);
            }
        }

        std.log.info("{any} -> {any}", .{ .{ x, y }, self.scroll_pos });

        if (self.scroll_pos[0] != x or self.scroll_pos[1] != y) {
            self.dirty = true;
        }
    }

    fn scrollBad(self: *App, offset: [2]i32) void {
        const o = self.scroll_pos;

        inline for (0..2) |i| {
            if (offset[i] >= 0) {
                self.scroll_pos[i] +|= @bitCast(offset[i]);
            } else {
                self.scroll_pos[i] -|= @bitCast(-offset[i]);
            }
        }

        std.log.info("{any} -> {any}", .{ o, self.scroll_pos });

        if (self.scroll_pos[0] != o[0] or self.scroll_pos[1] != o[1]) {
            self.dirty = true;
        }
    }
};

pub fn main() void {
    {
        var app = App{};
        app.scrollGood(.{ 0, 1 });
        std.log.info("{}", .{app.dirty});
    }
    {
        var app = App{};
        app.scrollBad(.{ 0, 1 });
        std.log.info("{}", .{app.dirty});
    }
}

outputs:

info: { 0, 0 } -> { 0, 1 }
info: true
info: { 0, 0 } -> { 0, 1 }
info: false

Expected Behavior

the output of scrollGood and scrollBad should be identical

info: { 0, 0 } -> { 0, 1 }
info: true
info: { 0, 0 } -> { 0, 1 }
info: true

[Vexu]

Fixed by reverting #13972 @shwqf

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 10323b688c..f01c27042b 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -6382,34 +6382,6 @@ pub const FuncGen = struct {
                 const elem_alignment = elem_ty.abiAlignment(mod).toLlvm();
                 return self.loadByRef(elem_ptr, elem_ty, elem_alignment, .normal);
             } else {
-                if (bin_op.lhs.toIndex()) |lhs_index| {
-                    if (self.air.instructions.items(.tag)[@intFromEnum(lhs_index)] == .load) {
-                        const load_data = self.air.instructions.items(.data)[@intFromEnum(lhs_index)];
-                        const load_ptr = load_data.ty_op.operand;
-                        if (load_ptr.toIndex()) |load_ptr_index| {
-                            const load_ptr_tag = self.air.instructions.items(.tag)[@intFromEnum(load_ptr_index)];
-                            switch (load_ptr_tag) {
-                                .struct_field_ptr,
-                                .struct_field_ptr_index_0,
-                                .struct_field_ptr_index_1,
-                                .struct_field_ptr_index_2,
-                                .struct_field_ptr_index_3,
-                                => {
-                                    const load_ptr_inst = try self.resolveInst(load_ptr);
-                                    const gep = try self.wip.gep(
-                                        .inbounds,
-                                        array_llvm_ty,
-                                        load_ptr_inst,
-                                        &indices,
-                                        "",
-                                    );
-                                    return self.loadTruncate(.normal, elem_ty, gep, .default);
-                                },
-                                else => {},
-                            }
-                        }
-                    }
-                }
                 const elem_ptr =
                     try self.wip.gep(.inbounds, array_llvm_ty, array_llvm_val, &indices, "");
                 return self.loadTruncate(.normal, elem_ty, elem_ptr, .default);