From 6a48345649de9d0ad5c948ca1ddd3277de046567 Mon Sep 17 00:00:00 2001
From: William Sengir <william@sengir.com>
Date: Sat, 26 Mar 2022 15:25:31 -0700
Subject: [PATCH 1/2] Sema: remove redundant `mul_add` comptime vectorization

Moving comptime vectorization into `Value` has proven to simplify and
clean up a lot of code.
---
 src/Sema.zig | 48 ++----------------------------------------------
 1 file changed, 2 insertions(+), 46 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d2295a01a8..b7580511cc 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -15190,52 +15190,8 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
             if (maybe_addend) |addend_val| {
                 if (addend_val.isUndef()) return sema.addConstUndef(ty);
-
-                switch (ty.zigTypeTag()) {
-                    .ComptimeFloat, .Float => {
-                        const result_val = try Value.mulAdd(
-                            ty,
-                            mulend1_val,
-                            mulend2_val,
-                            addend_val,
-                            sema.arena,
-                            target,
-                        );
-                        return sema.addConstant(ty, result_val);
-                    },
-                    .Vector => {
-                        const scalar_ty = ty.scalarType();
-                        switch (scalar_ty.zigTypeTag()) {
-                            .ComptimeFloat, .Float => {},
-                            else => return sema.fail(block, src, "expected vector of floats, found vector of '{}'", .{scalar_ty.fmt(target)}),
-                        }
-
-                        const vec_len = ty.vectorLen();
-                        const result_ty = try Type.vector(sema.arena, vec_len, scalar_ty);
-                        var mulend1_buf: Value.ElemValueBuffer = undefined;
-                        var mulend2_buf: Value.ElemValueBuffer = undefined;
-                        var addend_buf: Value.ElemValueBuffer = undefined;
-                        const elems = try sema.arena.alloc(Value, vec_len);
-                        for (elems) |*elem, i| {
-                            const mulend1_elem_val = mulend1_val.elemValueBuffer(i, &mulend1_buf);
-                            const mulend2_elem_val = mulend2_val.elemValueBuffer(i, &mulend2_buf);
-                            const addend_elem_val = addend_val.elemValueBuffer(i, &addend_buf);
-                            elem.* = try Value.mulAdd(
-                                scalar_ty,
-                                mulend1_elem_val,
-                                mulend2_elem_val,
-                                addend_elem_val,
-                                sema.arena,
-                                target,
-                            );
-                        }
-                        return sema.addConstant(
-                            result_ty,
-                            try Value.Tag.aggregate.create(sema.arena, elems),
-                        );
-                    },
-                    else => unreachable,
-                }
+                const result_val = try Value.mulAdd(ty, mulend1_val, mulend2_val, addend_val, sema.arena, target);
+                return sema.addConstant(ty, result_val);
             } else {
                 break :rs addend_src;
             }

From adc2824fa405beeea25edacd9362d1f66f8f9520 Mon Sep 17 00:00:00 2001
From: William Sengir <william@sengir.com>
Date: Sat, 26 Mar 2022 15:30:13 -0700
Subject: [PATCH 2/2] stage2: simplify `scalar_ty` for `mul_add` in LLVM
 backend

---
 src/codegen/llvm.zig | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index df7f05948d..049f7bfad6 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -5218,6 +5218,7 @@ pub const FuncGen = struct {
 
         const ty = self.air.typeOfIndex(inst);
         const llvm_ty = try self.dg.llvmType(ty);
+        const scalar_ty = ty.scalarType();
         const target = self.dg.module.getTarget();
 
         const Strat = union(enum) {
@@ -5225,11 +5226,6 @@ pub const FuncGen = struct {
             libc: [*:0]const u8,
         };
 
-        const scalar_ty = if (ty.zigTypeTag() == .Vector)
-            ty.elemType()
-        else
-            ty;
-
         const strat: Strat = switch (scalar_ty.floatBits(target)) {
             16, 32, 64 => Strat.intrinsic,
             80 => if (CType.longdouble.sizeInBits(target) == 80) Strat{ .intrinsic = {} } else Strat{ .libc = "__fmax" },