stage2: implement @ctz and @clz including SIMD

AIR:
 * `array_elem_val` is now allowed to be used with a vector as the array
   type.
 * New instructions: splat, vector_init

AstGen:
 * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding
   an unnecessary `as` instruction, since the coercion will be performed
   in Sema.
 * Builtins that accept vectors now ignore the type parameter. Comment
   from this commit reproduced here:

   The accepted proposal ziglang#6835 tells us to remove the type parameter from
   these builtins. To stay source-compatible with stage1, we still observe
   the parameter here, but we do not encode it into the ZIR. To implement
   this proposal in stage2, only AstGen code will need to be changed.

Sema:
 * `clz` and `ctz` ZIR instructions are now handled by the same function
   which accept AIR tag and comptime eval function pointer to
   differentiate.
 * `@typeInfo` for vectors is implemented.
 * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎
 * `elemValue` is implemented for vectors, when the index is a scalar.
   Handling a vector index is still TODO.
 * Element-wise coercion is implemented for vectors. It could probably
   be optimized a bit, but it is at least complete & correct.
 * `Type.intInfo` supports vectors, returning int info for the element.
 * `Value.ctz` initial implementation. Needs work.
 * `Value.eql` is implemented for arrays and vectors.

LLVM backend:
 * Implement vector support when lowering `array_elem_val`.
 * Implement vector support when lowering `ctz` and `clz`.
 * Implement `splat` and `vector_init`.

Author: andrewrk

lib/std/testing.zig

@@ -103,11 +103,13 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
 
         .Array => |array| try expectEqualSlices(array.child, &expected, &actual),
 
-        .Vector => |vectorType| {
+        .Vector => |info| {
             var i: usize = 0;
-            while (i < vectorType.len) : (i += 1) {
+            while (i < info.len) : (i += 1) {
                 if (!std.meta.eql(expected[i], actual[i])) {
-                    std.debug.print("index {} incorrect. expected {}, found {}\n", .{ i, expected[i], actual[i] });
+                    std.debug.print("index {} incorrect. expected {}, found {}\n", .{
+                        i, expected[i], actual[i],
+                    });
                     return error.TestExpectedEqual;
                 }
             }

src/Air.zig

@@ -426,7 +426,8 @@ pub const Inst = struct {
         /// Given a pointer to a slice, return a pointer to the pointer of the slice.
         /// Uses the `ty_op` field.
         ptr_slice_ptr_ptr,
-        /// Given an array value and element index, return the element value at that index.
+        /// Given an (array value or vector value) and element index,
+        /// return the element value at that index.
         /// Result type is the element type of the array operand.
         /// Uses the `bin_op` field.
         array_elem_val,
@@ -455,6 +456,10 @@ pub const Inst = struct {
         /// Given an integer operand, return the float with the closest mathematical meaning.
         /// Uses the `ty_op` field.
         int_to_float,
+        /// Given an integer, bool, float, or pointer operand, return a vector with all elements
+        /// equal to the scalar value.
+        /// Uses the `ty_op` field.
+        splat,
 
         /// Given dest ptr, value, and len, set all elements at dest to value.
         /// Result type is always void.
@@ -505,6 +510,11 @@ pub const Inst = struct {
         /// Uses the `un_op` field.
         error_name,
 
+        /// Constructs a vector value out of runtime-known elements.
+        /// Uses the `ty_pl` field, payload is index of an array of elements, each of which
+        /// is a `Ref`. Length of the array is given by the vector type.
+        vector_init,
+
         pub fn fromCmpOp(op: std.math.CompareOperator) Tag {
             return switch (op) {
                 .lt => .cmp_lt,
@@ -756,6 +766,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .cmpxchg_weak,
         .cmpxchg_strong,
         .slice,
+        .vector_init,
         => return air.getRefType(datas[inst].ty_pl.ty),
 
         .not,
@@ -785,6 +796,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .array_to_slice,
         .float_to_int,
         .int_to_float,
+        .splat,
         .get_union_tag,
         .clz,
         .ctz,

src/AstGen.zig

@@ -7060,7 +7060,7 @@ fn builtinCall(
         },
 
         .splat => {
-            const len = try expr(gz, scope, .{ .ty = .u32_type }, params[0]);
+            const len = try expr(gz, scope, .{ .coerced_ty = .u32_type }, params[0]);
             const scalar = try expr(gz, scope, .none, params[1]);
             const result = try gz.addPlNode(.splat, node, Zir.Inst.Bin{
                 .lhs = len,
@@ -7395,8 +7395,14 @@ fn bitBuiltin(
     operand_node: Ast.Node.Index,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
-    const int_type = try typeExpr(gz, scope, int_type_node);
-    const operand = try expr(gz, scope, .{ .ty = int_type }, operand_node);
+    // The accepted proposal https://github.com/ziglang/zig/issues/6835
+    // tells us to remove the type parameter from these builtins. To stay
+    // source-compatible with stage1, we still observe the parameter here,
+    // but we do not encode it into the ZIR. To implement this proposal in
+    // stage2, only AstGen code will need to be changed.
+    _ = try typeExpr(gz, scope, int_type_node);
+
+    const operand = try expr(gz, scope, .none, operand_node);
     const result = try gz.addUnNode(tag, operand, node);
     return rvalue(gz, rl, result, node);
 }

src/Liveness.zig

@@ -26,7 +26,8 @@ tomb_bits: []usize,
 /// array. The meaning of the data depends on the AIR tag.
 ///  * `cond_br` - points to a `CondBr` in `extra` at this index.
 ///  * `switch_br` - points to a `SwitchBr` in `extra` at this index.
-///  * `asm`, `call` - the value is a set of bits which are the extra tomb bits of operands.
+///  * `asm`, `call`, `vector_init` - the value is a set of bits which are the extra tomb
+///    bits of operands.
 ///    The main tomb bits are still used and the extra ones are starting with the lsb of the
 ///    value here.
 special: std.AutoHashMapUnmanaged(Air.Inst.Index, u32),
@@ -316,6 +317,7 @@ fn analyzeInst(
         .clz,
         .ctz,
         .popcount,
+        .splat,
         => {
             const o = inst_datas[inst].ty_op;
             return trackOperands(a, new_set, inst, main_tomb, .{ o.operand, .none, .none });
@@ -345,7 +347,7 @@ fn analyzeInst(
             const callee = inst_data.operand;
             const extra = a.air.extraData(Air.Call, inst_data.payload);
             const args = @bitCast([]const Air.Inst.Ref, a.air.extra[extra.end..][0..extra.data.args_len]);
-            if (args.len <= bpi - 2) {
+            if (args.len + 1 <= bpi - 1) {
                 var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1);
                 buf[0] = callee;
                 std.mem.copy(Air.Inst.Ref, buf[1..], args);
@@ -363,6 +365,28 @@ fn analyzeInst(
             }
             return extra_tombs.finish();
         },
+        .vector_init => {
+            const ty_pl = inst_datas[inst].ty_pl;
+            const vector_ty = a.air.getRefType(ty_pl.ty);
+            const len = @intCast(u32, vector_ty.arrayLen());
+            const elements = @bitCast([]const Air.Inst.Ref, a.air.extra[ty_pl.payload..][0..len]);
+
+            if (elements.len <= bpi - 1) {
+                var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1);
+                std.mem.copy(Air.Inst.Ref, &buf, elements);
+                return trackOperands(a, new_set, inst, main_tomb, buf);
+            }
+            var extra_tombs: ExtraTombs = .{
+                .analysis = a,
+                .new_set = new_set,
+                .inst = inst,
+                .main_tomb = main_tomb,
+            };
+            for (elements) |elem| {
+                try extra_tombs.feed(elem);
+            }
+            return extra_tombs.finish();
+        },
         .struct_field_ptr, .struct_field_val => {
             const extra = a.air.extraData(Air.StructField, inst_datas[inst].ty_pl.payload).data;
             return trackOperands(a, new_set, inst, main_tomb, .{ extra.struct_operand, .none, .none });