Commit 0a909a6712fac386c635043d0a25539f69b3998f | zig

author	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-04-17 18:57:30+02:00
committer	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-04-19 22:40:50+02:00
log	0a909a6712fac386c635043d0a25539f69b3998f
tree	15a0618dcb3a8421b8adba4c134c261b0df1966f
parent	d9d9fea6aee7fd0f4dadb53e41f9884330229051
signature	Commit is signed but in an unrecognized format.

stage2 AArch64: implement addwrap, subwrap, mulwrap

2 files changed, 36 insertions(+), 29 deletions(-)

src
- arch
  - aarch64
    CodeGen.zig
test
- behavior
  - math.zig

src/arch/aarch64/CodeGen.zig+36-21

 @@ -512,13 +512,13 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
         switch (air_tags[inst]) {
             // zig fmt: off
             .add, .ptr_add   => try self.airBinOp(inst),
-            .addwrap         => try self.airAddWrap(inst),
+            .addwrap         => try self.airBinOp(inst),
             .add_sat         => try self.airAddSat(inst),
             .sub, .ptr_sub   => try self.airBinOp(inst),
-            .subwrap         => try self.airSubWrap(inst),
+            .subwrap         => try self.airBinOp(inst),
             .sub_sat         => try self.airSubSat(inst),
             .mul             => try self.airBinOp(inst),
-            .mulwrap         => try self.airMulWrap(inst),
+            .mulwrap         => try self.airBinOp(inst),
             .mul_sat         => try self.airMulSat(inst),
             .rem             => try self.airRem(inst),
             .mod             => try self.airMod(inst),
 @@ -1531,6 +1531,39 @@ fn binOp(
                 else => unreachable,
             }
         },
+        .addwrap,
+        .subwrap,
+        .mulwrap,
+        => {
+            const base_tag: Air.Inst.Tag = switch (tag) {
+                .addwrap => .add,
+                .subwrap => .sub,
+                .mulwrap => .mul,
+                else => unreachable,
+            };
+            // Generate an add/sub/mul
+            const result = try self.binOp(base_tag, maybe_inst, lhs, rhs, lhs_ty, rhs_ty);
+            // Truncate if necessary
+            switch (lhs_ty.zigTypeTag()) {
+                .Vector => return self.fail("TODO binary operations on vectors", .{}),
+                .Int => {
+                    const int_info = lhs_ty.intInfo(self.target.*);
+                    if (int_info.bits <= 64) {
+                        const result_reg = result.register;
+                        if (int_info.bits < 64) {
+                            try self.truncRegister(result_reg, result_reg, int_info.signedness, int_info.bits);
+                            return result;
+                        } else return result;
+                    } else {
+                        return self.fail("TODO binary operations on integers > u64/i64", .{});
+                    }
+                },
+                else => unreachable,
+            }
+        },
         // Bitwise operations on integers
         .bit_and,
         .bit_or,
 @@ -1633,36 +1666,18 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
 }
-fn airAddWrap(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement addwrap for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
 fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
     const bin_op = self.air.instructions.items(.data)[inst].bin_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
     return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
 }
-fn airSubWrap(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement subwrap for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
 fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
     const bin_op = self.air.instructions.items(.data)[inst].bin_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
     return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
 }
-fn airMulWrap(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mulwrap for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
 fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
     const bin_op = self.air.instructions.items(.data)[inst].bin_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});

test/behavior/math.zig-8

...	@@ -499,8 +499,6 @@ fn mod(comptime T: type, a: T, b: T) T {	...	@@ -499,8 +499,6 @@ fn mod(comptime T: type, a: T, b: T) T {
499	}	499	}
500		500
501	test "unsigned wrapping" {	501	test "unsigned wrapping" {
502	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
503
504	try testUnsignedWrappingEval(maxInt(u32));	502	try testUnsignedWrappingEval(maxInt(u32));
505	comptime try testUnsignedWrappingEval(maxInt(u32));	503	comptime try testUnsignedWrappingEval(maxInt(u32));
506	}	504	}
...	@@ -512,8 +510,6 @@ fn testUnsignedWrappingEval(x: u32) !void {	...	@@ -512,8 +510,6 @@ fn testUnsignedWrappingEval(x: u32) !void {
512	}	510	}
513		511
514	test "signed wrapping" {	512	test "signed wrapping" {
515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
516
517	try testSignedWrappingEval(maxInt(i32));	513	try testSignedWrappingEval(maxInt(i32));
518	comptime try testSignedWrappingEval(maxInt(i32));	514	comptime try testSignedWrappingEval(maxInt(i32));
519	}	515	}
...	@@ -525,8 +521,6 @@ fn testSignedWrappingEval(x: i32) !void {	...	@@ -525,8 +521,6 @@ fn testSignedWrappingEval(x: i32) !void {
525	}	521	}
526		522
527	test "signed negation wrapping" {	523	test "signed negation wrapping" {
528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
529
530	try testSignedNegationWrappingEval(minInt(i16));	524	try testSignedNegationWrappingEval(minInt(i16));
531	comptime try testSignedNegationWrappingEval(minInt(i16));	525	comptime try testSignedNegationWrappingEval(minInt(i16));
532	}	526	}
...	@@ -537,8 +531,6 @@ fn testSignedNegationWrappingEval(x: i16) !void {	...	@@ -537,8 +531,6 @@ fn testSignedNegationWrappingEval(x: i16) !void {
537	}	531	}
538		532
539	test "unsigned negation wrapping" {	533	test "unsigned negation wrapping" {
540	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
541
542	try testUnsignedNegationWrappingEval(1);	534	try testUnsignedNegationWrappingEval(1);
543	comptime try testUnsignedNegationWrappingEval(1);	535	comptime try testUnsignedNegationWrappingEval(1);
544	}	536	}