[RISCV] Support LMUL!=1 for __attribute__((riscv_rvv_vector_bits(N)))

[craig.topper]

Summary

The first patch supported only LMUL=1 types. This patch supports
LMUL!=1.

LMUL is length multiplier that allows multiple vector registers to
be treated as one large register or a fraction of a single vector
register. Supported values for LMUL are 1/8, 1/4, 1/2, 1, 2, 4, and 8.

An LMUL=2 type will be twice as large as an LMUL=1 type. An LMUL=1/2
type will be half the size as an LMUL=1 type.

Type name with "m2" is LMUL=2, "m4" is LMUL=4.
Type name with "mf2" is LMUL=1/2, "mf4" is LMUL=1/4.

For the LMUL!=1 types the user will need to scale __riscv_v_fixed_vlen
by the LMUL before passing to the attribute.

[asb]

clang/include/clang/Basic/AttrDocs.td

2347–2350

LMULo -> LMUL

[craig.topper]

Fix typo

[craig.topper]

Ping

[craig.topper]

Ping

[craig.topper]

Ping * 3

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

2350

Do you have test coverage that demonstrates this?

clang/lib/AST/Type.cpp

2437

FIXME is now stale and can be removed?

clang/lib/Sema/SemaType.cpp

8338

Random thought I didn't think to ask earlier: is it possible for this multiplication to overflow (if so, we should add test coverage to make sure we don't do bad things)?

[craig.topper]

clang/lib/Sema/SemaType.cpp

8338

The largest value for -mrvv-vector-bits is 65536 which makes VScale->first 65536/64 == 1024. MinElts and EltSize should be small enough that it won't overflow.

I'm not sure if there's any protection if someone bypasses the driver with -Xclang -mvscale-min= and uses a larger value.

[craig.topper]

Remove stale FIXME

[aaron.ballman]

LGTM

clang/lib/Sema/SemaType.cpp

8338

The largest value for -mrvv-vector-bits is 65536 which makes VScale->first 65536/64 == 1024. MinElts and EltSize should be small enough that it won't overflow.

Fantastic, thank you!

I'm not sure if there's any protection if someone bypasses the driver with -Xclang -mvscale-min= and uses a larger value.

IMO, using cc1 options is compiler YOLO-mode, so I don't mind if this has no protection.

clang/include/clang/Basic/AttrDocs.td

 
 Creates a type ``fixed_vint8m1_t_t`` that is a fixed-length variant of
 ``vint8m1_t`` that contains exactly 512 bits. Unlike ``vint8m1_t``, this type
 can be used in globals, structs, unions, and arrays, all of which are
 unsupported for sizeless types.
 
 The attribute can be attached to a single RVV vector (such as ``vint8m1_t``).
 The attribute will be rejected unless
-``N==__riscv_v_fixed_vlen``, the implementation defined feature macro that
+``N==(__riscv_v_fixed_vlen*LMUL)``, the implementation defined feature macro that
 is enabled under the ``-mrvv-vector-bits`` flag. ``__riscv_v_fixed_vlen`` can
 only be a power of 2 between 64 and 65536.
 
-Only ``*m1_t`` (LMUL=1) types are supported at this time.
+For types where LMUL!=1, ``__riscv_v_fixed_vlen`` needs to be scaled by the LMUL
+of the type before passing to the attribute.
+
+``vbool*_t`` types are not supported at this time.
 }];
 }
 
 def AVRInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "interrupt (AVR)";
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt))`` attribute on

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_attribute_arm_feature_sve_bits_unsupported : Error<
   "%0 is only supported when '-msve-vector-bits=<bits>' is specified with a "
   "value of 128, 256, 512, 1024 or 2048.">;
 def err_sve_vector_in_non_sve_target : Error<
   "SVE vector type %0 cannot be used in a target without sve">;
 def err_attribute_riscv_rvv_bits_unsupported : Error<
   "%0 is only supported when '-mrvv-vector-bits=<bits>' is specified with a "
   "value of \"zvl\" or a power 2 in the range [64,65536]">;
 def err_attribute_bad_rvv_vector_size : Error<
-  "invalid RVV vector size '%0', must match value set by "
-  "'-mrvv-vector-bits' ('%1')">;
+  "invalid RVV vector size '%0', expected size is '%1' based on LMUL of type "
+  "and '-mrvv-vector-bits'">;
 def err_attribute_invalid_rvv_type : Error<
   "%0 attribute applied to non-RVV type %1">;
 def err_attribute_requires_positive_integer : Error<
   "%0 attribute requires a %select{positive|non-negative}1 "
   "integral compile time constant expression">;
 def err_attribute_requires_opencl_version : Error<
   "attribute %0 is supported in the OpenCL version %1%select{| onwards}2">;
 def err_invalid_branch_protection_spec : Error<

clang/lib/AST/ASTContext.cpp

 //===- ASTContext.cpp - Context to hold long-lived AST nodes --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool ASTContext::areCompatibleRVVTypes(QualType FirstType,
   assert(
       ((FirstType->isRVVSizelessBuiltinType() && SecondType->isVectorType()) ||
        (FirstType->isVectorType() && SecondType->isRVVSizelessBuiltinType())) &&
       "Expected RVV builtin type and vector type!");
 
   auto IsValidCast = [this](QualType FirstType, QualType SecondType) {
     if (const auto *BT = FirstType->getAs<BuiltinType>()) {
       if (const auto *VT = SecondType->getAs<VectorType>()) {
-        if (VT->getVectorKind() == VectorType::RVVFixedLengthDataVector)
-          return FirstType->isRVVVLSBuiltinType() &&
-                 VT->getElementType().getCanonicalType() ==
-                     FirstType->getRVVEltType(*this);
-        if (VT->getVectorKind() == VectorType::GenericVector)
+        if (VT->getVectorKind() == VectorType::RVVFixedLengthDataVector ||
+            VT->getVectorKind() == VectorType::GenericVector)
           return FirstType->isRVVVLSBuiltinType() &&
                  getTypeSize(SecondType) == getRVVTypeSize(*this, BT) &&
                  hasSameType(VT->getElementType(),
                              getBuiltinVectorTypeInfo(BT).ElementType);
       }
     }
     return false;
   };

clang/lib/AST/Type.cpp

 //===- Type.cpp - Type representation and manipulation --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (BTy->getKind() == BuiltinType::SveBool)
     return Ctx.UnsignedCharTy;
   else
     return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
 }
 
 bool Type::isRVVVLSBuiltinType() const {
   if (const BuiltinType *BT = getAs<BuiltinType>()) {
     switch (BT->getKind()) {
     // FIXME: Support more than LMUL 1.
 #define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, IsFP) \
     case BuiltinType::Id: \
-      return NF == 1 && (NumEls * ElBits) == llvm::RISCV::RVVBitsPerBlock;
+      return NF == 1;
 #include "clang/Basic/RISCVVTypes.def"
     default:
       return false;
     }
   }
   return false;
 }
 

clang/lib/Sema/SemaType.cpp

 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateInstCallback.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/TargetParser/RISCVTargetParser.h"
 #include <bitset>
 #include <optional>
 
 using namespace clang;
 
 enum TypeDiagSelector {
   TDS_Function,
   TDS_Pointer,
static void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType,
   unsigned VecSize = static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
 
   ASTContext::BuiltinVectorTypeInfo Info =
       S.Context.getBuiltinVectorTypeInfo(CurType->getAs<BuiltinType>());
   unsigned EltSize = S.Context.getTypeSize(Info.ElementType);
   unsigned MinElts = Info.EC.getKnownMinValue();
 
   // The attribute vector size must match -mrvv-vector-bits.
-  if (VecSize != VScale->first * MinElts * EltSize) {
+  unsigned ExpectedSize = VScale->first * MinElts * EltSize;
+  if (VecSize != ExpectedSize) {
     S.Diag(Attr.getLoc(), diag::err_attribute_bad_rvv_vector_size)
-        << VecSize << VScale->first * llvm::RISCV::RVVBitsPerBlock;
+        << VecSize << ExpectedSize;
     Attr.setInvalid();
     return;
   }
 
   VectorType::VectorKind VecKind = VectorType::RVVFixedLengthDataVector;
   VecSize /= EltSize;
   CurType = S.Context.getVectorType(Info.ElementType, VecSize, VecKind);
 }

clang/test/CodeGen/attr-riscv-rvv-vector-bits-codegen.c

 typedef __rvv_uint16m1_t vuint16m1_t;
 typedef __rvv_int32m1_t vint32m1_t;
 typedef __rvv_uint32m1_t vuint32m1_t;
 typedef __rvv_int64m1_t vint64m1_t;
 typedef __rvv_uint64m1_t vuint64m1_t;
 typedef __rvv_float32m1_t vfloat32m1_t;
 typedef __rvv_float64m1_t vfloat64m1_t;
 
+typedef __rvv_int8m2_t vint8m2_t;
+typedef __rvv_uint8m2_t vuint8m2_t;
+typedef __rvv_int16m2_t vint16m2_t;
+typedef __rvv_uint16m2_t vuint16m2_t;
+typedef __rvv_int32m2_t vint32m2_t;
+typedef __rvv_uint32m2_t vuint32m2_t;
+typedef __rvv_int64m2_t vint64m2_t;
+typedef __rvv_uint64m2_t vuint64m2_t;
+typedef __rvv_float32m2_t vfloat32m2_t;
+typedef __rvv_float64m2_t vfloat64m2_t;
+
 typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
+typedef vint32m2_t fixed_int32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
 
 fixed_int32m1_t global_vec;
+fixed_int32m2_t global_vec_m2;
 
 // CHECK-LABEL: @test_ptr_to_global(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[RETVAL:%.*]] = alloca <8 x i32>, align 8
 // CHECK-NEXT:    [[GLOBAL_VEC_PTR:%.*]] = alloca ptr, align 8
 // CHECK-NEXT:    store ptr @global_vec, ptr [[GLOBAL_VEC_PTR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[GLOBAL_VEC_PTR]], align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i32>, ptr [[TMP0]], align 8

 // CHECK-NEXT:    store <8 x i32> [[CASTFIXEDSVE]], ptr [[RETVAL]], align 8
 // CHECK-NEXT:    [[TMP3:%.*]] = load <8 x i32>, ptr [[RETVAL]], align 8
 // CHECK-NEXT:    [[CASTSCALABLESVE1:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v8i32(<vscale x 2 x i32> undef, <8 x i32> [[TMP3]], i64 0)
 // CHECK-NEXT:    ret <vscale x 2 x i32> [[CASTSCALABLESVE1]]
 //
 fixed_int32m1_t test_cast(vint32m1_t vec) {
   return __riscv_vadd(global_vec, vec, __riscv_v_fixed_vlen/32);
 }
+
+// CHECK-LABEL: @test_ptr_to_global_m2(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[RETVAL:%.*]] = alloca <16 x i32>, align 8
+// CHECK-NEXT:    [[GLOBAL_VEC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    store ptr @global_vec_m2, ptr [[GLOBAL_VEC_PTR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[GLOBAL_VEC_PTR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[TMP0]], align 8
+// CHECK-NEXT:    store <16 x i32> [[TMP1]], ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[CASTSCALABLESVE:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP2]], i64 0)
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CASTSCALABLESVE]]
+//
+fixed_int32m2_t test_ptr_to_global_m2() {
+  fixed_int32m2_t *global_vec_ptr;
+  global_vec_ptr = &global_vec_m2;
+  return *global_vec_ptr;
+}
+
+//
+// Test casting pointer from fixed-length array to scalable vector.
+// CHECK-LABEL: @array_arg_m2(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[RETVAL:%.*]] = alloca <16 x i32>, align 8
+// CHECK-NEXT:    [[ARR_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    store ptr [[ARR:%.*]], ptr [[ARR_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[ARR_ADDR]], align 8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds <16 x i32>, ptr [[TMP0]], i64 0
+// CHECK-NEXT:    [[TMP1:%.*]] = load <16 x i32>, ptr [[ARRAYIDX]], align 8
+// CHECK-NEXT:    store <16 x i32> [[TMP1]], ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[CASTSCALABLESVE:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP2]], i64 0)
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CASTSCALABLESVE]]
+//
+fixed_int32m2_t array_arg_m2(fixed_int32m2_t arr[]) {
+  return arr[0];
+}
+
+// CHECK-LABEL: @test_cast_m2(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[RETVAL:%.*]] = alloca <16 x i32>, align 8
+// CHECK-NEXT:    [[VEC_ADDR:%.*]] = alloca <vscale x 4 x i32>, align 4
+// CHECK-NEXT:    store <vscale x 4 x i32> [[VEC:%.*]], ptr [[VEC_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load <16 x i32>, ptr @global_vec_m2, align 8
+// CHECK-NEXT:    [[CASTSCALABLESVE:%.*]] = call <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v16i32(<vscale x 4 x i32> undef, <16 x i32> [[TMP0]], i64 0)
+// CHECK-NEXT:    [[TMP1:%.*]] = load <vscale x 4 x i32>, ptr [[VEC_ADDR]], align 4
+// CHECK-NEXT:    [[TMP2:%.*]] = call <vscale x 4 x i32> @llvm.riscv.vadd.nxv4i32.nxv4i32.i64(<vscale x 4 x i32> poison, <vscale x 4 x i32> [[CASTSCALABLESVE]], <vscale x 4 x i32> [[TMP1]], i64 16)
+// CHECK-NEXT:    [[CASTFIXEDSVE:%.*]] = call <16 x i32> @llvm.vector.extract.v16i32.nxv4i32(<vscale x 4 x i32> [[TMP2]], i64 0)
+// CHECK-NEXT:    store <16 x i32> [[CASTFIXEDSVE]], ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
+// CHECK-NEXT:    [[CASTSCALABLESVE1:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP3]], i64 0)
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CASTSCALABLESVE1]]
+//
+fixed_int32m2_t test_cast_m2(vint32m2_t vec) {
+  return __riscv_vadd(global_vec_m2, vec, __riscv_v_fixed_vlen/16);
+}

clang/test/CodeGen/attr-riscv-rvv-vector-bits-types.c

 typedef __rvv_uint16m1_t vuint16m1_t;
 typedef __rvv_int32m1_t vint32m1_t;
 typedef __rvv_uint32m1_t vuint32m1_t;
 typedef __rvv_int64m1_t vint64m1_t;
 typedef __rvv_uint64m1_t vuint64m1_t;
 typedef __rvv_float32m1_t vfloat32m1_t;
 typedef __rvv_float64m1_t vfloat64m1_t;
 
+typedef __rvv_int8m2_t vint8m2_t;
+typedef __rvv_uint8m2_t vuint8m2_t;
+typedef __rvv_int16m2_t vint16m2_t;
+typedef __rvv_uint16m2_t vuint16m2_t;
+typedef __rvv_int32m2_t vint32m2_t;
+typedef __rvv_uint32m2_t vuint32m2_t;
+typedef __rvv_int64m2_t vint64m2_t;
+typedef __rvv_uint64m2_t vuint64m2_t;
+typedef __rvv_float32m2_t vfloat32m2_t;
+typedef __rvv_float64m2_t vfloat64m2_t;
+
+typedef __rvv_int8m4_t vint8m4_t;
+typedef __rvv_uint8m4_t vuint8m4_t;
+typedef __rvv_int16m4_t vint16m4_t;
+typedef __rvv_uint16m4_t vuint16m4_t;
+typedef __rvv_int32m4_t vint32m4_t;
+typedef __rvv_uint32m4_t vuint32m4_t;
+typedef __rvv_int64m4_t vint64m4_t;
+typedef __rvv_uint64m4_t vuint64m4_t;
+typedef __rvv_float32m4_t vfloat32m4_t;
+typedef __rvv_float64m4_t vfloat64m4_t;
+
+typedef __rvv_int8m8_t vint8m8_t;
+typedef __rvv_uint8m8_t vuint8m8_t;
+typedef __rvv_int16m8_t vint16m8_t;
+typedef __rvv_uint16m8_t vuint16m8_t;
+typedef __rvv_int32m8_t vint32m8_t;
+typedef __rvv_uint32m8_t vuint32m8_t;
+typedef __rvv_int64m8_t vint64m8_t;
+typedef __rvv_uint64m8_t vuint64m8_t;
+typedef __rvv_float32m8_t vfloat32m8_t;
+typedef __rvv_float64m8_t vfloat64m8_t;
+
 // Define valid fixed-width RVV types
 typedef vint8m1_t fixed_int8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint16m1_t fixed_int16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
 typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
 typedef vfloat32m1_t fixed_float32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vfloat64m1_t fixed_float64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
+typedef vint8m2_t fixed_int8m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint16m2_t fixed_int16m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint32m2_t fixed_int32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint64m2_t fixed_int64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vuint8m2_t fixed_uint8m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint16m2_t fixed_uint16m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint32m2_t fixed_uint32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint64m2_t fixed_uint64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vfloat32m2_t fixed_float32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vfloat64m2_t fixed_float64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vint8m4_t fixed_int8m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint16m4_t fixed_int16m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint32m4_t fixed_int32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint64m4_t fixed_int64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vuint8m4_t fixed_uint8m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint16m4_t fixed_uint16m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint32m4_t fixed_uint32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint64m4_t fixed_uint64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vfloat32m4_t fixed_float32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vfloat64m4_t fixed_float64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vint8m8_t fixed_int8m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint16m8_t fixed_int16m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint32m8_t fixed_int32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint64m8_t fixed_int64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
+typedef vuint8m8_t fixed_uint8m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint16m8_t fixed_uint16m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint32m8_t fixed_uint32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint64m8_t fixed_uint64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
+typedef vfloat32m8_t fixed_float32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vfloat64m8_t fixed_float64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
 //===----------------------------------------------------------------------===//
 // Structs and unions
 //===----------------------------------------------------------------------===//
 #define DEFINE_STRUCT(ty) \
   struct struct_##ty {    \
     fixed_##ty##_t x;     \
   } struct_##ty;
 
 #define DEFINE_UNION(ty) \
   union union_##ty {     \
     fixed_##ty##_t x;    \
   } union_##ty;
 
 DEFINE_STRUCT(int8m1)
 DEFINE_STRUCT(int16m1)
 DEFINE_STRUCT(int32m1)
 DEFINE_STRUCT(int64m1)
 DEFINE_STRUCT(uint8m1)
 DEFINE_STRUCT(uint16m1)
 DEFINE_STRUCT(uint32m1)
 DEFINE_STRUCT(uint64m1)
 DEFINE_STRUCT(float32m1)
 DEFINE_STRUCT(float64m1)
 
+DEFINE_STRUCT(int8m2)
+DEFINE_STRUCT(int16m2)
+DEFINE_STRUCT(int32m2)
+DEFINE_STRUCT(int64m2)
+DEFINE_STRUCT(uint8m2)
+DEFINE_STRUCT(uint16m2)
+DEFINE_STRUCT(uint32m2)
+DEFINE_STRUCT(uint64m2)
+DEFINE_STRUCT(float32m2)
+DEFINE_STRUCT(float64m2)
+
+DEFINE_STRUCT(int8m4)
+DEFINE_STRUCT(int16m4)
+DEFINE_STRUCT(int32m4)
+DEFINE_STRUCT(int64m4)
+DEFINE_STRUCT(uint8m4)
+DEFINE_STRUCT(uint16m4)
+DEFINE_STRUCT(uint32m4)
+DEFINE_STRUCT(uint64m4)
+DEFINE_STRUCT(float32m4)
+DEFINE_STRUCT(float64m4)
+
+DEFINE_STRUCT(int8m8)
+DEFINE_STRUCT(int16m8)
+DEFINE_STRUCT(int32m8)
+DEFINE_STRUCT(int64m8)
+DEFINE_STRUCT(uint8m8)
+DEFINE_STRUCT(uint16m8)
+DEFINE_STRUCT(uint32m8)
+DEFINE_STRUCT(uint64m8)
+DEFINE_STRUCT(float32m8)
+DEFINE_STRUCT(float64m8)
+
 DEFINE_UNION(int8m1)
 DEFINE_UNION(int16m1)
 DEFINE_UNION(int32m1)
 DEFINE_UNION(int64m1)
 DEFINE_UNION(uint8m1)
 DEFINE_UNION(uint16m1)
 DEFINE_UNION(uint32m1)
 DEFINE_UNION(uint64m1)
 DEFINE_UNION(float32m1)
 DEFINE_UNION(float64m1)
 
+DEFINE_UNION(int8m2)
+DEFINE_UNION(int16m2)
+DEFINE_UNION(int32m2)
+DEFINE_UNION(int64m2)
+DEFINE_UNION(uint8m2)
+DEFINE_UNION(uint16m2)
+DEFINE_UNION(uint32m2)
+DEFINE_UNION(uint64m2)
+DEFINE_UNION(float32m2)
+DEFINE_UNION(float64m2)
+
+DEFINE_UNION(int8m4)
+DEFINE_UNION(int16m4)
+DEFINE_UNION(int32m4)
+DEFINE_UNION(int64m4)
+DEFINE_UNION(uint8m4)
+DEFINE_UNION(uint16m4)
+DEFINE_UNION(uint32m4)
+DEFINE_UNION(uint64m4)
+DEFINE_UNION(float32m4)
+DEFINE_UNION(float64m4)
+
+DEFINE_UNION(int8m8)
+DEFINE_UNION(int16m8)
+DEFINE_UNION(int32m8)
+DEFINE_UNION(int64m8)
+DEFINE_UNION(uint8m8)
+DEFINE_UNION(uint16m8)
+DEFINE_UNION(uint32m8)
+DEFINE_UNION(uint64m8)
+DEFINE_UNION(float32m8)
+DEFINE_UNION(float64m8)
+
 //===----------------------------------------------------------------------===//
 // Global variables
 //===----------------------------------------------------------------------===//
 fixed_int8m1_t global_i8;
 fixed_int16m1_t global_i16;
 fixed_int32m1_t global_i32;
 fixed_int64m1_t global_i64;
 
 fixed_uint8m1_t global_u8;
 fixed_uint16m1_t global_u16;
 fixed_uint32m1_t global_u32;
 fixed_uint64m1_t global_u64;
 
 fixed_float32m1_t global_f32;
 fixed_float64m1_t global_f64;
 
+fixed_int8m2_t global_i8m2;
+fixed_int16m2_t global_i16m2;
+fixed_int32m2_t global_i32m2;
+fixed_int64m2_t global_i64m2;
+
+fixed_uint8m2_t global_u8m2;
+fixed_uint16m2_t global_u16m2;
+fixed_uint32m2_t global_u32m2;
+fixed_uint64m2_t global_u64m2;
+
+fixed_float32m2_t global_f32m2;
+fixed_float64m2_t global_f64m2;
+
+fixed_int8m4_t global_i8m4;
+fixed_int16m4_t global_i16m4;
+fixed_int32m4_t global_i32m4;
+fixed_int64m4_t global_i64m4;
+
+fixed_uint8m4_t global_u8m4;
+fixed_uint16m4_t global_u16m4;
+fixed_uint32m4_t global_u32m4;
+fixed_uint64m4_t global_u64m4;
+
+fixed_float32m4_t global_f32m4;
+fixed_float64m4_t global_f64m4;
+
+fixed_int8m8_t global_i8m8;
+fixed_int16m8_t global_i16m8;
+fixed_int32m8_t global_i32m8;
+fixed_int64m8_t global_i64m8;
+
+fixed_uint8m8_t global_u8m8;
+fixed_uint16m8_t global_u16m8;
+fixed_uint32m8_t global_u32m8;
+fixed_uint64m8_t global_u64m8;
+
+fixed_float32m8_t global_f32m8;
+fixed_float64m8_t global_f64m8;
+
 //===----------------------------------------------------------------------===//
 // Global arrays
 //===----------------------------------------------------------------------===//
 fixed_int8m1_t global_arr_i8[3];
 fixed_int16m1_t global_arr_i16[3];
 fixed_int32m1_t global_arr_i32[3];
 fixed_int64m1_t global_arr_i64[3];
 
 fixed_uint8m1_t global_arr_u8[3];
 fixed_uint16m1_t global_arr_u16[3];
 fixed_uint32m1_t global_arr_u32[3];
 fixed_uint64m1_t global_arr_u64[3];
 
 fixed_float32m1_t global_arr_f32[3];
 fixed_float64m1_t global_arr_f64[3];
 
+fixed_int8m2_t global_arr_i8m2[3];
+fixed_int16m2_t global_arr_i16m2[3];
+fixed_int32m2_t global_arr_i32m2[3];
+fixed_int64m2_t global_arr_i64m2[3];
+
+fixed_uint8m2_t global_arr_u8m2[3];
+fixed_uint16m2_t global_arr_u16m2[3];
+fixed_uint32m2_t global_arr_u32m2[3];
+fixed_uint64m2_t global_arr_u64m2[3];
+
+fixed_float32m2_t global_arr_f32m2[3];
+fixed_float64m2_t global_arr_f64m2[3];
+
+fixed_int8m4_t global_arr_i8m4[3];
+fixed_int16m4_t global_arr_i16m4[3];
+fixed_int32m4_t global_arr_i32m4[3];
+fixed_int64m4_t global_arr_i64m4[3];
+
+fixed_uint8m4_t global_arr_u8m4[3];
+fixed_uint16m4_t global_arr_u16m4[3];
+fixed_uint32m4_t global_arr_u32m4[3];
+fixed_uint64m4_t global_arr_u64m4[3];
+
+fixed_float32m4_t global_arr_f32m4[3];
+fixed_float64m4_t global_arr_f64m4[3];
+
+fixed_int8m8_t global_arr_i8m8[3];
+fixed_int16m8_t global_arr_i16m8[3];
+fixed_int32m8_t global_arr_i32m8[3];
+fixed_int64m8_t global_arr_i64m8[3];
+
+fixed_uint8m8_t global_arr_u8m8[3];
+fixed_uint16m8_t global_arr_u16m8[3];
+fixed_uint32m8_t global_arr_u32m8[3];
+fixed_uint64m8_t global_arr_u64m8[3];
+
+fixed_float32m8_t global_arr_f32m8[3];
+fixed_float64m8_t global_arr_f64m8[3];
+
 //===----------------------------------------------------------------------===//
 // Locals
 //===----------------------------------------------------------------------===//
 void f() {
   // Variables
   fixed_int8m1_t local_i8;
   fixed_int16m1_t local_i16;
   fixed_int32m1_t local_i32;
   fixed_int64m1_t local_i64;
   fixed_uint8m1_t local_u8;
   fixed_uint16m1_t local_u16;
   fixed_uint32m1_t local_u32;
   fixed_uint64m1_t local_u64;
   fixed_float32m1_t local_f32;
   fixed_float64m1_t local_f64;
 
+  fixed_int8m2_t local_i8m2;
+  fixed_int16m2_t local_i16m2;
+  fixed_int32m2_t local_i32m2;
+  fixed_int64m2_t local_i64m2;
+  fixed_uint8m2_t local_u8m2;
+  fixed_uint16m2_t local_u16m2;
+  fixed_uint32m2_t local_u32m2;
+  fixed_uint64m2_t local_u64m2;
+  fixed_float32m2_t local_f32m2;
+  fixed_float64m2_t local_f64m2;
+
+  fixed_int8m4_t local_i8m4;
+  fixed_int16m4_t local_i16m4;
+  fixed_int32m4_t local_i32m4;
+  fixed_int64m4_t local_i64m4;
+  fixed_uint8m4_t local_u8m4;
+  fixed_uint16m4_t local_u16m4;
+  fixed_uint32m4_t local_u32m4;
+  fixed_uint64m4_t local_u64m4;
+  fixed_float32m4_t local_f32m4;
+  fixed_float64m4_t local_f64m4;
+
+  fixed_int8m8_t local_i8m8;
+  fixed_int16m8_t local_i16m8;
+  fixed_int32m8_t local_i32m8;
+  fixed_int64m8_t local_i64m8;
+  fixed_uint8m8_t local_u8m8;
+  fixed_uint16m8_t local_u16m8;
+  fixed_uint32m8_t local_u32m8;
+  fixed_uint64m8_t local_u64m8;
+  fixed_float32m8_t local_f32m8;
+  fixed_float64m8_t local_f64m8;
+
   // Arrays
   fixed_int8m1_t local_arr_i8[3];
   fixed_int16m1_t local_arr_i16[3];
   fixed_int32m1_t local_arr_i32[3];
   fixed_int64m1_t local_arr_i64[3];
   fixed_uint8m1_t local_arr_u8[3];
   fixed_uint16m1_t local_arr_u16[3];
   fixed_uint32m1_t local_arr_u32[3];
   fixed_uint64m1_t local_arr_u64[3];
   fixed_float32m1_t local_arr_f32[3];
   fixed_float64m1_t local_arr_f64[3];
+
+  fixed_int8m2_t local_arr_i8m2[3];
+  fixed_int16m2_t local_arr_i16m2[3];
+  fixed_int32m2_t local_arr_i32m2[3];
+  fixed_int64m2_t local_arr_i64m2[3];
+  fixed_uint8m2_t local_arr_u8m2[3];
+  fixed_uint16m2_t local_arr_u16m2[3];
+  fixed_uint32m2_t local_arr_u32m2[3];
+  fixed_uint64m2_t local_arr_u64m2[3];
+  fixed_float32m2_t local_arr_f32m2[3];
+  fixed_float64m2_t local_arr_f64m2[3];
+
+  fixed_int8m4_t local_arr_i8m4[3];
+  fixed_int16m4_t local_arr_i16m4[3];
+  fixed_int32m4_t local_arr_i32m4[3];
+  fixed_int64m4_t local_arr_i64m4[3];
+  fixed_uint8m4_t local_arr_u8m4[3];
+  fixed_uint16m4_t local_arr_u16m4[3];
+  fixed_uint32m4_t local_arr_u32m4[3];
+  fixed_uint64m4_t local_arr_u64m4[3];
+  fixed_float32m4_t local_arr_f32m4[3];
+  fixed_float64m4_t local_arr_f64m4[3];
+
+  fixed_int8m8_t local_arr_i8m8[3];
+  fixed_int16m8_t local_arr_i16m8[3];
+  fixed_int32m8_t local_arr_i32m8[3];
+  fixed_int64m8_t local_arr_i64m8[3];
+  fixed_uint8m8_t local_arr_u8m8[3];
+  fixed_uint16m8_t local_arr_u16m8[3];
+  fixed_uint32m8_t local_arr_u32m8[3];
+  fixed_uint64m8_t local_arr_u64m8[3];
+  fixed_float32m8_t local_arr_f32m8[3];
+  fixed_float64m8_t local_arr_f64m8[3];
 }
 
 //===----------------------------------------------------------------------===//
 // Structs and unions
 //===----------------------------------------------------------------------===//
 // CHECK-64:      %struct.struct_int8m1 = type { <8 x i8> }
 // CHECK-64-NEXT: %struct.struct_int16m1 = type { <4 x i16> }
 // CHECK-64-NEXT: %struct.struct_int32m1 = type { <2 x i32> }
 // CHECK-64-NEXT: %struct.struct_int64m1 = type { <1 x i64> }
 // CHECK-64-NEXT: %struct.struct_uint8m1 = type { <8 x i8> }
 // CHECK-64-NEXT: %struct.struct_uint16m1 = type { <4 x i16> }
 // CHECK-64-NEXT: %struct.struct_uint32m1 = type { <2 x i32> }
 // CHECK-64-NEXT: %struct.struct_uint64m1 = type { <1 x i64> }
 // CHECK-64-NEXT: %struct.struct_float32m1 = type { <2 x float> }
 // CHECK-64-NEXT: %struct.struct_float64m1 = type { <1 x double> }
+// CHECK-64-NEXT: %struct.struct_int8m2 = type { <16 x i8> }
+// CHECK-64-NEXT: %struct.struct_int16m2 = type { <8 x i16> }
+// CHECK-64-NEXT: %struct.struct_int32m2 = type { <4 x i32> }
+// CHECK-64-NEXT: %struct.struct_int64m2 = type { <2 x i64> }
+// CHECK-64-NEXT: %struct.struct_uint8m2 = type { <16 x i8> }
+// CHECK-64-NEXT: %struct.struct_uint16m2 = type { <8 x i16> }
+// CHECK-64-NEXT: %struct.struct_uint32m2 = type { <4 x i32> }
+// CHECK-64-NEXT: %struct.struct_uint64m2 = type { <2 x i64> }
+// CHECK-64-NEXT: %struct.struct_float32m2 = type { <4 x float> }
+// CHECK-64-NEXT: %struct.struct_float64m2 = type { <2 x double> }
+// CHECK-64-NEXT: %struct.struct_int8m4 = type { <32 x i8> }
+// CHECK-64-NEXT: %struct.struct_int16m4 = type { <16 x i16> }
+// CHECK-64-NEXT: %struct.struct_int32m4 = type { <8 x i32> }
+// CHECK-64-NEXT: %struct.struct_int64m4 = type { <4 x i64> }
+// CHECK-64-NEXT: %struct.struct_uint8m4 = type { <32 x i8> }
+// CHECK-64-NEXT: %struct.struct_uint16m4 = type { <16 x i16> }
+// CHECK-64-NEXT: %struct.struct_uint32m4 = type { <8 x i32> }
+// CHECK-64-NEXT: %struct.struct_uint64m4 = type { <4 x i64> }
+// CHECK-64-NEXT: %struct.struct_float32m4 = type { <8 x float> }
+// CHECK-64-NEXT: %struct.struct_float64m4 = type { <4 x double> }
+// CHECK-64-NEXT: %struct.struct_int8m8 = type { <64 x i8> }
+// CHECK-64-NEXT: %struct.struct_int16m8 = type { <32 x i16> }
+// CHECK-64-NEXT: %struct.struct_int32m8 = type { <16 x i32> }
+// CHECK-64-NEXT: %struct.struct_int64m8 = type { <8 x i64> }
+// CHECK-64-NEXT: %struct.struct_uint8m8 = type { <64 x i8> }
+// CHECK-64-NEXT: %struct.struct_uint16m8 = type { <32 x i16> }
+// CHECK-64-NEXT: %struct.struct_uint32m8 = type { <16 x i32> }
+// CHECK-64-NEXT: %struct.struct_uint64m8 = type { <8 x i64> }
+// CHECK-64-NEXT: %struct.struct_float32m8 = type { <16 x float> }
+// CHECK-64-NEXT: %struct.struct_float64m8 = type { <8 x double> }
 
 // CHECK-128:      %struct.struct_int8m1 = type { <16 x i8> }
 // CHECK-128-NEXT: %struct.struct_int16m1 = type { <8 x i16> }
 // CHECK-128-NEXT: %struct.struct_int32m1 = type { <4 x i32> }
 // CHECK-128-NEXT: %struct.struct_int64m1 = type { <2 x i64> }
 // CHECK-128-NEXT: %struct.struct_uint8m1 = type { <16 x i8> }
 // CHECK-128-NEXT: %struct.struct_uint16m1 = type { <8 x i16> }
 // CHECK-128-NEXT: %struct.struct_uint32m1 = type { <4 x i32> }
 // CHECK-128-NEXT: %struct.struct_uint64m1 = type { <2 x i64> }
 // CHECK-128-NEXT: %struct.struct_float32m1 = type { <4 x float> }
 // CHECK-128-NEXT: %struct.struct_float64m1 = type { <2 x double> }
+// CHECK-128-NEXT: %struct.struct_int8m2 = type { <32 x i8> }
+// CHECK-128-NEXT: %struct.struct_int16m2 = type { <16 x i16> }
+// CHECK-128-NEXT: %struct.struct_int32m2 = type { <8 x i32> }
+// CHECK-128-NEXT: %struct.struct_int64m2 = type { <4 x i64> }
+// CHECK-128-NEXT: %struct.struct_uint8m2 = type { <32 x i8> }
+// CHECK-128-NEXT: %struct.struct_uint16m2 = type { <16 x i16> }
+// CHECK-128-NEXT: %struct.struct_uint32m2 = type { <8 x i32> }
+// CHECK-128-NEXT: %struct.struct_uint64m2 = type { <4 x i64> }
+// CHECK-128-NEXT: %struct.struct_float32m2 = type { <8 x float> }
+// CHECK-128-NEXT: %struct.struct_float64m2 = type { <4 x double> }
+// CHECK-128-NEXT: %struct.struct_int8m4 = type { <64 x i8> }
+// CHECK-128-NEXT: %struct.struct_int16m4 = type { <32 x i16> }
+// CHECK-128-NEXT: %struct.struct_int32m4 = type { <16 x i32> }
+// CHECK-128-NEXT: %struct.struct_int64m4 = type { <8 x i64> }
+// CHECK-128-NEXT: %struct.struct_uint8m4 = type { <64 x i8> }
+// CHECK-128-NEXT: %struct.struct_uint16m4 = type { <32 x i16> }
+// CHECK-128-NEXT: %struct.struct_uint32m4 = type { <16 x i32> }
+// CHECK-128-NEXT: %struct.struct_uint64m4 = type { <8 x i64> }
+// CHECK-128-NEXT: %struct.struct_float32m4 = type { <16 x float> }
+// CHECK-128-NEXT: %struct.struct_float64m4 = type { <8 x double> }
+// CHECK-128-NEXT: %struct.struct_int8m8 = type { <128 x i8> }
+// CHECK-128-NEXT: %struct.struct_int16m8 = type { <64 x i16> }
+// CHECK-128-NEXT: %struct.struct_int32m8 = type { <32 x i32> }
+// CHECK-128-NEXT: %struct.struct_int64m8 = type { <16 x i64> }
+// CHECK-128-NEXT: %struct.struct_uint8m8 = type { <128 x i8> }
+// CHECK-128-NEXT: %struct.struct_uint16m8 = type { <64 x i16> }
+// CHECK-128-NEXT: %struct.struct_uint32m8 = type { <32 x i32> }
+// CHECK-128-NEXT: %struct.struct_uint64m8 = type { <16 x i64> }
+// CHECK-128-NEXT: %struct.struct_float32m8 = type { <32 x float> }
+// CHECK-128-NEXT: %struct.struct_float64m8 = type { <16 x double> }
 
 // CHECK-256:      %struct.struct_int8m1 = type { <32 x i8> }
 // CHECK-256-NEXT: %struct.struct_int16m1 = type { <16 x i16> }
 // CHECK-256-NEXT: %struct.struct_int32m1 = type { <8 x i32> }
 // CHECK-256-NEXT: %struct.struct_int64m1 = type { <4 x i64> }
 // CHECK-256-NEXT: %struct.struct_uint8m1 = type { <32 x i8> }
 // CHECK-256-NEXT: %struct.struct_uint16m1 = type { <16 x i16> }
 // CHECK-256-NEXT: %struct.struct_uint32m1 = type { <8 x i32> }
 // CHECK-256-NEXT: %struct.struct_uint64m1 = type { <4 x i64> }
 // CHECK-256-NEXT: %struct.struct_float32m1 = type { <8 x float> }
 // CHECK-256-NEXT: %struct.struct_float64m1 = type { <4 x double> }
+// CHECK-256-NEXT: %struct.struct_int8m2 = type { <64 x i8> }
+// CHECK-256-NEXT: %struct.struct_int16m2 = type { <32 x i16> }
+// CHECK-256-NEXT: %struct.struct_int32m2 = type { <16 x i32> }
+// CHECK-256-NEXT: %struct.struct_int64m2 = type { <8 x i64> }
+// CHECK-256-NEXT: %struct.struct_uint8m2 = type { <64 x i8> }
+// CHECK-256-NEXT: %struct.struct_uint16m2 = type { <32 x i16> }
+// CHECK-256-NEXT: %struct.struct_uint32m2 = type { <16 x i32> }
+// CHECK-256-NEXT: %struct.struct_uint64m2 = type { <8 x i64> }
+// CHECK-256-NEXT: %struct.struct_float32m2 = type { <16 x float> }
+// CHECK-256-NEXT: %struct.struct_float64m2 = type { <8 x double> }
+// CHECK-256-NEXT: %struct.struct_int8m4 = type { <128 x i8> }
+// CHECK-256-NEXT: %struct.struct_int16m4 = type { <64 x i16> }
+// CHECK-256-NEXT: %struct.struct_int32m4 = type { <32 x i32> }
+// CHECK-256-NEXT: %struct.struct_int64m4 = type { <16 x i64> }
+// CHECK-256-NEXT: %struct.struct_uint8m4 = type { <128 x i8> }
+// CHECK-256-NEXT: %struct.struct_uint16m4 = type { <64 x i16> }
+// CHECK-256-NEXT: %struct.struct_uint32m4 = type { <32 x i32> }
+// CHECK-256-NEXT: %struct.struct_uint64m4 = type { <16 x i64> }
+// CHECK-256-NEXT: %struct.struct_float32m4 = type { <32 x float> }
+// CHECK-256-NEXT: %struct.struct_float64m4 = type { <16 x double> }
+// CHECK-256-NEXT: %struct.struct_int8m8 = type { <256 x i8> }
+// CHECK-256-NEXT: %struct.struct_int16m8 = type { <128 x i16> }
+// CHECK-256-NEXT: %struct.struct_int32m8 = type { <64 x i32> }
+// CHECK-256-NEXT: %struct.struct_int64m8 = type { <32 x i64> }
+// CHECK-256-NEXT: %struct.struct_uint8m8 = type { <256 x i8> }
+// CHECK-256-NEXT: %struct.struct_uint16m8 = type { <128 x i16> }
+// CHECK-256-NEXT: %struct.struct_uint32m8 = type { <64 x i32> }
+// CHECK-256-NEXT: %struct.struct_uint64m8 = type { <32 x i64> }
+// CHECK-256-NEXT: %struct.struct_float32m8 = type { <64 x float> }
 
 // CHECK-512:      %struct.struct_int8m1 = type { <64 x i8> }
 // CHECK-512-NEXT: %struct.struct_int16m1 = type { <32 x i16> }
 // CHECK-512-NEXT: %struct.struct_int32m1 = type { <16 x i32> }
 // CHECK-512-NEXT: %struct.struct_int64m1 = type { <8 x i64> }
 // CHECK-512-NEXT: %struct.struct_uint8m1 = type { <64 x i8> }
 // CHECK-512-NEXT: %struct.struct_uint16m1 = type { <32 x i16> }
 // CHECK-512-NEXT: %struct.struct_uint32m1 = type { <16 x i32> }
 // CHECK-512-NEXT: %struct.struct_uint64m1 = type { <8 x i64> }
 // CHECK-512-NEXT: %struct.struct_float32m1 = type { <16 x float> }
 // CHECK-512-NEXT: %struct.struct_float64m1 = type { <8 x double> }
+// CHECK-512-NEXT: %struct.struct_int8m2 = type { <128 x i8> }
+// CHECK-512-NEXT: %struct.struct_int16m2 = type { <64 x i16> }
+// CHECK-512-NEXT: %struct.struct_int32m2 = type { <32 x i32> }
+// CHECK-512-NEXT: %struct.struct_int64m2 = type { <16 x i64> }
+// CHECK-512-NEXT: %struct.struct_uint8m2 = type { <128 x i8> }
+// CHECK-512-NEXT: %struct.struct_uint16m2 = type { <64 x i16> }
+// CHECK-512-NEXT: %struct.struct_uint32m2 = type { <32 x i32> }
+// CHECK-512-NEXT: %struct.struct_uint64m2 = type { <16 x i64> }
+// CHECK-512-NEXT: %struct.struct_float32m2 = type { <32 x float> }
+// CHECK-512-NEXT: %struct.struct_float64m2 = type { <16 x double> }
+// CHECK-512-NEXT: %struct.struct_int8m4 = type { <256 x i8> }
+// CHECK-512-NEXT: %struct.struct_int16m4 = type { <128 x i16> }
+// CHECK-512-NEXT: %struct.struct_int32m4 = type { <64 x i32> }
+// CHECK-512-NEXT: %struct.struct_int64m4 = type { <32 x i64> }
+// CHECK-512-NEXT: %struct.struct_uint8m4 = type { <256 x i8> }
+// CHECK-512-NEXT: %struct.struct_uint16m4 = type { <128 x i16> }
+// CHECK-512-NEXT: %struct.struct_uint32m4 = type { <64 x i32> }
+// CHECK-512-NEXT: %struct.struct_uint64m4 = type { <32 x i64> }
+// CHECK-512-NEXT: %struct.struct_float32m4 = type { <64 x float> }
+// CHECK-512-NEXT: %struct.struct_float64m4 = type { <32 x double> }
+// CHECK-512-NEXT: %struct.struct_int8m8 = type { <512 x i8> }
+// CHECK-512-NEXT: %struct.struct_int16m8 = type { <256 x i16> }
+// CHECK-512-NEXT: %struct.struct_int32m8 = type { <128 x i32> }
+// CHECK-512-NEXT: %struct.struct_int64m8 = type { <64 x i64> }
+// CHECK-512-NEXT: %struct.struct_uint8m8 = type { <512 x i8> }
+// CHECK-512-NEXT: %struct.struct_uint16m8 = type { <256 x i16> }
+// CHECK-512-NEXT: %struct.struct_uint32m8 = type { <128 x i32> }
+// CHECK-512-NEXT: %struct.struct_uint64m8 = type { <64 x i64> }
+// CHECK-512-NEXT: %struct.struct_float32m8 = type { <128 x float> }
 
 // CHECK-1024:      %struct.struct_int8m1 = type { <128 x i8> }
 // CHECK-1024-NEXT: %struct.struct_int16m1 = type { <64 x i16> }
 // CHECK-1024-NEXT: %struct.struct_int32m1 = type { <32 x i32> }
 // CHECK-1024-NEXT: %struct.struct_int64m1 = type { <16 x i64> }
 // CHECK-1024-NEXT: %struct.struct_uint8m1 = type { <128 x i8> }
 // CHECK-1024-NEXT: %struct.struct_uint16m1 = type { <64 x i16> }
 // CHECK-1024-NEXT: %struct.struct_uint32m1 = type { <32 x i32> }
 // CHECK-1024-NEXT: %struct.struct_uint64m1 = type { <16 x i64> }
 // CHECK-1024-NEXT: %struct.struct_float32m1 = type { <32 x float> }
 // CHECK-1024-NEXT: %struct.struct_float64m1 = type { <16 x double> }
+// CHECK-1024-NEXT: %struct.struct_int8m2 = type { <256 x i8> }
+// CHECK-1024-NEXT: %struct.struct_int16m2 = type { <128 x i16> }
+// CHECK-1024-NEXT: %struct.struct_int32m2 = type { <64 x i32> }
+// CHECK-1024-NEXT: %struct.struct_int64m2 = type { <32 x i64> }
+// CHECK-1024-NEXT: %struct.struct_uint8m2 = type { <256 x i8> }
+// CHECK-1024-NEXT: %struct.struct_uint16m2 = type { <128 x i16> }
+// CHECK-1024-NEXT: %struct.struct_uint32m2 = type { <64 x i32> }
+// CHECK-1024-NEXT: %struct.struct_uint64m2 = type { <32 x i64> }
+// CHECK-1024-NEXT: %struct.struct_float32m2 = type { <64 x float> }
+// CHECK-1024-NEXT: %struct.struct_float64m2 = type { <32 x double> }
+// CHECK-1024-NEXT: %struct.struct_int8m4 = type { <512 x i8> }
+// CHECK-1024-NEXT: %struct.struct_int16m4 = type { <256 x i16> }
+// CHECK-1024-NEXT: %struct.struct_int32m4 = type { <128 x i32> }
+// CHECK-1024-NEXT: %struct.struct_int64m4 = type { <64 x i64> }
+// CHECK-1024-NEXT: %struct.struct_uint8m4 = type { <512 x i8> }
+// CHECK-1024-NEXT: %struct.struct_uint16m4 = type { <256 x i16> }
+// CHECK-1024-NEXT: %struct.struct_uint32m4 = type { <128 x i32> }
+// CHECK-1024-NEXT: %struct.struct_uint64m4 = type { <64 x i64> }
+// CHECK-1024-NEXT: %struct.struct_float32m4 = type { <128 x float> }
+// CHECK-1024-NEXT: %struct.struct_float64m4 = type { <64 x double> }
+// CHECK-1024-NEXT: %struct.struct_int8m8 = type { <1024 x i8> }
+// CHECK-1024-NEXT: %struct.struct_int16m8 = type { <512 x i16> }
+// CHECK-1024-NEXT: %struct.struct_int32m8 = type { <256 x i32> }
+// CHECK-1024-NEXT: %struct.struct_int64m8 = type { <128 x i64> }
+// CHECK-1024-NEXT: %struct.struct_uint8m8 = type { <1024 x i8> }
+// CHECK-1024-NEXT: %struct.struct_uint16m8 = type { <512 x i16> }
+// CHECK-1024-NEXT: %struct.struct_uint32m8 = type { <256 x i32> }
+// CHECK-1024-NEXT: %struct.struct_uint64m8 = type { <128 x i64> }
+// CHECK-1024-NEXT: %struct.struct_float32m8 = type { <256 x float> }
 
 // CHECK-64:      %union.union_int8m1 = type { <8 x i8> }
 // CHECK-64-NEXT: %union.union_int16m1 = type { <4 x i16> }
 // CHECK-64-NEXT: %union.union_int32m1 = type { <2 x i32> }
 // CHECK-64-NEXT: %union.union_int64m1 = type { <1 x i64> }
 // CHECK-64-NEXT: %union.union_uint8m1 = type { <8 x i8> }
 // CHECK-64-NEXT: %union.union_uint16m1 = type { <4 x i16> }
 // CHECK-64-NEXT: %union.union_uint32m1 = type { <2 x i32> }
 // CHECK-64-NEXT: %union.union_uint64m1 = type { <1 x i64> }
 // CHECK-64-NEXT: %union.union_float32m1 = type { <2 x float> }
 // CHECK-64-NEXT: %union.union_float64m1 = type { <1 x double> }
+// CHECK-64-NEXT: %union.union_int8m2 = type { <16 x i8> }
+// CHECK-64-NEXT: %union.union_int16m2 = type { <8 x i16> }
+// CHECK-64-NEXT: %union.union_int32m2 = type { <4 x i32> }
+// CHECK-64-NEXT: %union.union_int64m2 = type { <2 x i64> }
+// CHECK-64-NEXT: %union.union_uint8m2 = type { <16 x i8> }
+// CHECK-64-NEXT: %union.union_uint16m2 = type { <8 x i16> }
+// CHECK-64-NEXT: %union.union_uint32m2 = type { <4 x i32> }
+// CHECK-64-NEXT: %union.union_uint64m2 = type { <2 x i64> }
+// CHECK-64-NEXT: %union.union_float32m2 = type { <4 x float> }
+// CHECK-64-NEXT: %union.union_float64m2 = type { <2 x double> }
+// CHECK-64-NEXT: %union.union_int8m4 = type { <32 x i8> }
+// CHECK-64-NEXT: %union.union_int16m4 = type { <16 x i16> }
+// CHECK-64-NEXT: %union.union_int32m4 = type { <8 x i32> }
+// CHECK-64-NEXT: %union.union_int64m4 = type { <4 x i64> }
+// CHECK-64-NEXT: %union.union_uint8m4 = type { <32 x i8> }
+// CHECK-64-NEXT: %union.union_uint16m4 = type { <16 x i16> }
+// CHECK-64-NEXT: %union.union_uint32m4 = type { <8 x i32> }
+// CHECK-64-NEXT: %union.union_uint64m4 = type { <4 x i64> }
+// CHECK-64-NEXT: %union.union_float32m4 = type { <8 x float> }
+// CHECK-64-NEXT: %union.union_float64m4 = type { <4 x double> }
+// CHECK-64-NEXT: %union.union_int8m8 = type { <64 x i8> }
+// CHECK-64-NEXT: %union.union_int16m8 = type { <32 x i16> }
+// CHECK-64-NEXT: %union.union_int32m8 = type { <16 x i32> }
+// CHECK-64-NEXT: %union.union_int64m8 = type { <8 x i64> }
+// CHECK-64-NEXT: %union.union_uint8m8 = type { <64 x i8> }
+// CHECK-64-NEXT: %union.union_uint16m8 = type { <32 x i16> }
+// CHECK-64-NEXT: %union.union_uint32m8 = type { <16 x i32> }
+// CHECK-64-NEXT: %union.union_uint64m8 = type { <8 x i64> }
+// CHECK-64-NEXT: %union.union_float32m8 = type { <16 x float> }
+// CHECK-64-NEXT: %union.union_float64m8 = type { <8 x double> }
 
 // CHECK-128:      %union.union_int8m1 = type { <16 x i8> }
 // CHECK-128-NEXT: %union.union_int16m1 = type { <8 x i16> }
 // CHECK-128-NEXT: %union.union_int32m1 = type { <4 x i32> }
 // CHECK-128-NEXT: %union.union_int64m1 = type { <2 x i64> }
 // CHECK-128-NEXT: %union.union_uint8m1 = type { <16 x i8> }
 // CHECK-128-NEXT: %union.union_uint16m1 = type { <8 x i16> }
 // CHECK-128-NEXT: %union.union_uint32m1 = type { <4 x i32> }
 // CHECK-128-NEXT: %union.union_uint64m1 = type { <2 x i64> }
 // CHECK-128-NEXT: %union.union_float32m1 = type { <4 x float> }
 // CHECK-128-NEXT: %union.union_float64m1 = type { <2 x double> }
+// CHECK-128-NEXT: %union.union_int8m2 = type { <32 x i8> }
+// CHECK-128-NEXT: %union.union_int16m2 = type { <16 x i16> }
+// CHECK-128-NEXT: %union.union_int32m2 = type { <8 x i32> }
+// CHECK-128-NEXT: %union.union_int64m2 = type { <4 x i64> }
+// CHECK-128-NEXT: %union.union_uint8m2 = type { <32 x i8> }
+// CHECK-128-NEXT: %union.union_uint16m2 = type { <16 x i16> }
+// CHECK-128-NEXT: %union.union_uint32m2 = type { <8 x i32> }
+// CHECK-128-NEXT: %union.union_uint64m2 = type { <4 x i64> }
+// CHECK-128-NEXT: %union.union_float32m2 = type { <8 x float> }
+// CHECK-128-NEXT: %union.union_float64m2 = type { <4 x double> }
+// CHECK-128-NEXT: %union.union_int8m4 = type { <64 x i8> }
+// CHECK-128-NEXT: %union.union_int16m4 = type { <32 x i16> }
+// CHECK-128-NEXT: %union.union_int32m4 = type { <16 x i32> }
+// CHECK-128-NEXT: %union.union_int64m4 = type { <8 x i64> }
+// CHECK-128-NEXT: %union.union_uint8m4 = type { <64 x i8> }
+// CHECK-128-NEXT: %union.union_uint16m4 = type { <32 x i16> }
+// CHECK-128-NEXT: %union.union_uint32m4 = type { <16 x i32> }
+// CHECK-128-NEXT: %union.union_uint64m4 = type { <8 x i64> }
+// CHECK-128-NEXT: %union.union_float32m4 = type { <16 x float> }
+// CHECK-128-NEXT: %union.union_float64m4 = type { <8 x double> }
+// CHECK-128-NEXT: %union.union_int8m8 = type { <128 x i8> }
+// CHECK-128-NEXT: %union.union_int16m8 = type { <64 x i16> }
+// CHECK-128-NEXT: %union.union_int32m8 = type { <32 x i32> }
+// CHECK-128-NEXT: %union.union_int64m8 = type { <16 x i64> }
+// CHECK-128-NEXT: %union.union_uint8m8 = type { <128 x i8> }
+// CHECK-128-NEXT: %union.union_uint16m8 = type { <64 x i16> }
+// CHECK-128-NEXT: %union.union_uint32m8 = type { <32 x i32> }
+// CHECK-128-NEXT: %union.union_uint64m8 = type { <16 x i64> }
+// CHECK-128-NEXT: %union.union_float32m8 = type { <32 x float> }
+// CHECK-128-NEXT: %union.union_float64m8 = type { <16 x double> }
 
 // CHECK-256:      %union.union_int8m1 = type { <32 x i8> }
 // CHECK-256-NEXT: %union.union_int16m1 = type { <16 x i16> }
 // CHECK-256-NEXT: %union.union_int32m1 = type { <8 x i32> }
 // CHECK-256-NEXT: %union.union_int64m1 = type { <4 x i64> }
 // CHECK-256-NEXT: %union.union_uint8m1 = type { <32 x i8> }
 // CHECK-256-NEXT: %union.union_uint16m1 = type { <16 x i16> }
 // CHECK-256-NEXT: %union.union_uint32m1 = type { <8 x i32> }
 // CHECK-256-NEXT: %union.union_uint64m1 = type { <4 x i64> }
 // CHECK-256-NEXT: %union.union_float32m1 = type { <8 x float> }
 // CHECK-256-NEXT: %union.union_float64m1 = type { <4 x double> }
+// CHECK-256-NEXT: %union.union_int8m2 = type { <64 x i8> }
+// CHECK-256-NEXT: %union.union_int16m2 = type { <32 x i16> }
+// CHECK-256-NEXT: %union.union_int32m2 = type { <16 x i32> }
+// CHECK-256-NEXT: %union.union_int64m2 = type { <8 x i64> }
+// CHECK-256-NEXT: %union.union_uint8m2 = type { <64 x i8> }
+// CHECK-256-NEXT: %union.union_uint16m2 = type { <32 x i16> }
+// CHECK-256-NEXT: %union.union_uint32m2 = type { <16 x i32> }
+// CHECK-256-NEXT: %union.union_uint64m2 = type { <8 x i64> }
+// CHECK-256-NEXT: %union.union_float32m2 = type { <16 x float> }
+// CHECK-256-NEXT: %union.union_float64m2 = type { <8 x double> }
+// CHECK-256-NEXT: %union.union_int8m4 = type { <128 x i8> }
+// CHECK-256-NEXT: %union.union_int16m4 = type { <64 x i16> }
+// CHECK-256-NEXT: %union.union_int32m4 = type { <32 x i32> }
+// CHECK-256-NEXT: %union.union_int64m4 = type { <16 x i64> }
+// CHECK-256-NEXT: %union.union_uint8m4 = type { <128 x i8> }
+// CHECK-256-NEXT: %union.union_uint16m4 = type { <64 x i16> }
+// CHECK-256-NEXT: %union.union_uint32m4 = type { <32 x i32> }
+// CHECK-256-NEXT: %union.union_uint64m4 = type { <16 x i64> }
+// CHECK-256-NEXT: %union.union_float32m4 = type { <32 x float> }
+// CHECK-256-NEXT: %union.union_float64m4 = type { <16 x double> }
+// CHECK-256-NEXT: %union.union_int8m8 = type { <256 x i8> }
+// CHECK-256-NEXT: %union.union_int16m8 = type { <128 x i16> }
+// CHECK-256-NEXT: %union.union_int32m8 = type { <64 x i32> }
+// CHECK-256-NEXT: %union.union_int64m8 = type { <32 x i64> }
+// CHECK-256-NEXT: %union.union_uint8m8 = type { <256 x i8> }
+// CHECK-256-NEXT: %union.union_uint16m8 = type { <128 x i16> }
+// CHECK-256-NEXT: %union.union_uint32m8 = type { <64 x i32> }
+// CHECK-256-NEXT: %union.union_uint64m8 = type { <32 x i64> }
+// CHECK-256-NEXT: %union.union_float32m8 = type { <64 x float> }
+// CHECK-256-NEXT: %union.union_float64m8 = type { <32 x double> }
 
 // CHECK-512:      %union.union_int8m1 = type { <64 x i8> }
 // CHECK-512-NEXT: %union.union_int16m1 = type { <32 x i16> }
 // CHECK-512-NEXT: %union.union_int32m1 = type { <16 x i32> }
 // CHECK-512-NEXT: %union.union_int64m1 = type { <8 x i64> }
 // CHECK-512-NEXT: %union.union_uint8m1 = type { <64 x i8> }
 // CHECK-512-NEXT: %union.union_uint16m1 = type { <32 x i16> }
 // CHECK-512-NEXT: %union.union_uint32m1 = type { <16 x i32> }
 // CHECK-512-NEXT: %union.union_uint64m1 = type { <8 x i64> }
 // CHECK-512-NEXT: %union.union_float32m1 = type { <16 x float> }
 // CHECK-512-NEXT: %union.union_float64m1 = type { <8 x double> }
+// CHECK-512-NEXT: %union.union_int8m2 = type { <128 x i8> }
+// CHECK-512-NEXT: %union.union_int16m2 = type { <64 x i16> }
+// CHECK-512-NEXT: %union.union_int32m2 = type { <32 x i32> }
+// CHECK-512-NEXT: %union.union_int64m2 = type { <16 x i64> }
+// CHECK-512-NEXT: %union.union_uint8m2 = type { <128 x i8> }
+// CHECK-512-NEXT: %union.union_uint16m2 = type { <64 x i16> }
+// CHECK-512-NEXT: %union.union_uint32m2 = type { <32 x i32> }
+// CHECK-512-NEXT: %union.union_uint64m2 = type { <16 x i64> }
+// CHECK-512-NEXT: %union.union_float32m2 = type { <32 x float> }
+// CHECK-512-NEXT: %union.union_float64m2 = type { <16 x double> }
+// CHECK-512-NEXT: %union.union_int8m4 = type { <256 x i8> }
+// CHECK-512-NEXT: %union.union_int16m4 = type { <128 x i16> }
+// CHECK-512-NEXT: %union.union_int32m4 = type { <64 x i32> }
+// CHECK-512-NEXT: %union.union_int64m4 = type { <32 x i64> }
+// CHECK-512-NEXT: %union.union_uint8m4 = type { <256 x i8> }
+// CHECK-512-NEXT: %union.union_uint16m4 = type { <128 x i16> }
+// CHECK-512-NEXT: %union.union_uint32m4 = type { <64 x i32> }
+// CHECK-512-NEXT: %union.union_uint64m4 = type { <32 x i64> }
+// CHECK-512-NEXT: %union.union_float32m4 = type { <64 x float> }
+// CHECK-512-NEXT: %union.union_float64m4 = type { <32 x double> }
+// CHECK-512-NEXT: %union.union_int8m8 = type { <512 x i8> }
+// CHECK-512-NEXT: %union.union_int16m8 = type { <256 x i16> }
+// CHECK-512-NEXT: %union.union_int32m8 = type { <128 x i32> }
+// CHECK-512-NEXT: %union.union_int64m8 = type { <64 x i64> }
+// CHECK-512-NEXT: %union.union_uint8m8 = type { <512 x i8> }
+// CHECK-512-NEXT: %union.union_uint16m8 = type { <256 x i16> }
+// CHECK-512-NEXT: %union.union_uint32m8 = type { <128 x i32> }
+// CHECK-512-NEXT: %union.union_uint64m8 = type { <64 x i64> }
+// CHECK-512-NEXT: %union.union_float32m8 = type { <128 x float> }
+// CHECK-512-NEXT: %union.union_float64m8 = type { <64 x double> }
 
 // CHECK-1024:      %union.union_int8m1 = type { <128 x i8> }
 // CHECK-1024-NEXT: %union.union_int16m1 = type { <64 x i16> }
 // CHECK-1024-NEXT: %union.union_int32m1 = type { <32 x i32> }
 // CHECK-1024-NEXT: %union.union_int64m1 = type { <16 x i64> }
 // CHECK-1024-NEXT: %union.union_uint8m1 = type { <128 x i8> }
 // CHECK-1024-NEXT: %union.union_uint16m1 = type { <64 x i16> }
 // CHECK-1024-NEXT: %union.union_uint32m1 = type { <32 x i32> }
 // CHECK-1024-NEXT: %union.union_uint64m1 = type { <16 x i64> }
 // CHECK-1024-NEXT: %union.union_float32m1 = type { <32 x float> }
 // CHECK-1024-NEXT: %union.union_float64m1 = type { <16 x double> }
+// CHECK-1024-NEXT: %union.union_int8m2 = type { <256 x i8> }
+// CHECK-1024-NEXT: %union.union_int16m2 = type { <128 x i16> }
+// CHECK-1024-NEXT: %union.union_int32m2 = type { <64 x i32> }
+// CHECK-1024-NEXT: %union.union_int64m2 = type { <32 x i64> }
+// CHECK-1024-NEXT: %union.union_uint8m2 = type { <256 x i8> }
+// CHECK-1024-NEXT: %union.union_uint16m2 = type { <128 x i16> }
+// CHECK-1024-NEXT: %union.union_uint32m2 = type { <64 x i32> }
+// CHECK-1024-NEXT: %union.union_uint64m2 = type { <32 x i64> }
+// CHECK-1024-NEXT: %union.union_float32m2 = type { <64 x float> }
+// CHECK-1024-NEXT: %union.union_float64m2 = type { <32 x double> }
+// CHECK-1024-NEXT: %union.union_int8m4 = type { <512 x i8> }
+// CHECK-1024-NEXT: %union.union_int16m4 = type { <256 x i16> }
+// CHECK-1024-NEXT: %union.union_int32m4 = type { <128 x i32> }
+// CHECK-1024-NEXT: %union.union_int64m4 = type { <64 x i64> }
+// CHECK-1024-NEXT: %union.union_uint8m4 = type { <512 x i8> }
+// CHECK-1024-NEXT: %union.union_uint16m4 = type { <256 x i16> }
+// CHECK-1024-NEXT: %union.union_uint32m4 = type { <128 x i32> }
+// CHECK-1024-NEXT: %union.union_uint64m4 = type { <64 x i64> }
+// CHECK-1024-NEXT: %union.union_float32m4 = type { <128 x float> }
+// CHECK-1024-NEXT: %union.union_float64m4 = type { <64 x double> }
+// CHECK-1024-NEXT: %union.union_int8m8 = type { <1024 x i8> }
+// CHECK-1024-NEXT: %union.union_int16m8 = type { <512 x i16> }
+// CHECK-1024-NEXT: %union.union_int32m8 = type { <256 x i32> }
+// CHECK-1024-NEXT: %union.union_int64m8 = type { <128 x i64> }
+// CHECK-1024-NEXT: %union.union_uint8m8 = type { <1024 x i8> }
+// CHECK-1024-NEXT: %union.union_uint16m8 = type { <512 x i16> }
+// CHECK-1024-NEXT: %union.union_uint32m8 = type { <256 x i32> }
+// CHECK-1024-NEXT: %union.union_uint64m8 = type { <128 x i64> }
+// CHECK-1024-NEXT: %union.union_float32m8 = type { <256 x float> }
+// CHECK-1024-NEXT: %union.union_float64m8 = type { <128 x double> }
 
 //===----------------------------------------------------------------------===//
 // Global variables
 //===----------------------------------------------------------------------===//
 // CHECK-64:      @global_i8 ={{.*}} global <8 x i8> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_i16 ={{.*}} global <4 x i16> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_i32 ={{.*}} global <2 x i32> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_i64 ={{.*}} global <1 x i64> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_u8 ={{.*}} global <8 x i8> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_u16 ={{.*}} global <4 x i16> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_u32 ={{.*}} global <2 x i32> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_u64 ={{.*}} global <1 x i64> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_f32 ={{.*}} global <2 x float> zeroinitializer, align 8
 // CHECK-64-NEXT: @global_f64 ={{.*}} global <1 x double> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i8m2 ={{.*}} global <16 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i16m2 ={{.*}} global <8 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i32m2 ={{.*}} global <4 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i64m2 ={{.*}} global <2 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u8m2 ={{.*}} global <16 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u16m2 ={{.*}} global <8 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u32m2 ={{.*}} global <4 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u64m2 ={{.*}} global <2 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f32m2 ={{.*}} global <4 x float> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f64m2 ={{.*}} global <2 x double> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i8m4 ={{.*}} global <32 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i16m4 ={{.*}} global <16 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i32m4 ={{.*}} global <8 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i64m4 ={{.*}} global <4 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u8m4 ={{.*}} global <32 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u16m4 ={{.*}} global <16 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u32m4 ={{.*}} global <8 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u64m4 ={{.*}} global <4 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f32m4 ={{.*}} global <8 x float> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f64m4 ={{.*}} global <4 x double> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i8m8 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i16m8 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i32m8 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_i64m8 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u8m8 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u16m8 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u32m8 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_u64m8 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f32m8 ={{.*}} global <16 x float> zeroinitializer, align 8
+// CHECK-64-NEXT: @global_f64m8 ={{.*}} global <8 x double> zeroinitializer, align 8
 
 // CHECK-128:      @global_i8 ={{.*}} global <16 x i8> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_i16 ={{.*}} global <8 x i16> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_i32 ={{.*}} global <4 x i32> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_i64 ={{.*}} global <2 x i64> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_u8 ={{.*}} global <16 x i8> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_u16 ={{.*}} global <8 x i16> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_u32 ={{.*}} global <4 x i32> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_u64 ={{.*}} global <2 x i64> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_f32 ={{.*}} global <4 x float> zeroinitializer, align 8
 // CHECK-128-NEXT: @global_f64 ={{.*}} global <2 x double> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i8m2 ={{.*}} global <32 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i16m2 ={{.*}} global <16 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i32m2 ={{.*}} global <8 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i64m2 ={{.*}} global <4 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u8m2 ={{.*}} global <32 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u16m2 ={{.*}} global <16 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u32m2 ={{.*}} global <8 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u64m2 ={{.*}} global <4 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f32m2 ={{.*}} global <8 x float> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f64m2 ={{.*}} global <4 x double> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i8m4 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i16m4 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i32m4 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i64m4 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u8m4 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u16m4 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u32m4 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u64m4 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f32m4 ={{.*}} global <16 x float> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f64m4 ={{.*}} global <8 x double> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i8m8 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i16m8 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i32m8 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_i64m8 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u8m8 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u16m8 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u32m8 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_u64m8 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f32m8 ={{.*}} global <32 x float> zeroinitializer, align 8
+// CHECK-128-NEXT: @global_f64m8 ={{.*}} global <16 x double> zeroinitializer, align 8
 
 // CHECK-256:      @global_i8 ={{.*}} global <32 x i8> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_i16 ={{.*}} global <16 x i16> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_i32 ={{.*}} global <8 x i32> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_i64 ={{.*}} global <4 x i64> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_u8 ={{.*}} global <32 x i8> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_u16 ={{.*}} global <16 x i16> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_u32 ={{.*}} global <8 x i32> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_u64 ={{.*}} global <4 x i64> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_f32 ={{.*}} global <8 x float> zeroinitializer, align 8
 // CHECK-256-NEXT: @global_f64 ={{.*}} global <4 x double> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i8m2 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i16m2 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i32m2 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i64m2 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u8m2 ={{.*}} global <64 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u16m2 ={{.*}} global <32 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u32m2 ={{.*}} global <16 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u64m2 ={{.*}} global <8 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f32m2 ={{.*}} global <16 x float> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f64m2 ={{.*}} global <8 x double> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i8m4 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i16m4 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i32m4 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i64m4 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u8m4 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u16m4 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u32m4 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u64m4 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f32m4 ={{.*}} global <32 x float> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f64m4 ={{.*}} global <16 x double> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i8m8 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i16m8 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i32m8 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_i64m8 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u8m8 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u16m8 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u32m8 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_u64m8 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f32m8 ={{.*}} global <64 x float> zeroinitializer, align 8
+// CHECK-256-NEXT: @global_f64m8 ={{.*}} global <32 x double> zeroinitializer, align 8
 
 // CHECK-512:      @global_i8 ={{.*}} global <64 x i8> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_i16 ={{.*}} global <32 x i16> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_i32 ={{.*}} global <16 x i32> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_i64 ={{.*}} global <8 x i64> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_u8 ={{.*}} global <64 x i8> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_u16 ={{.*}} global <32 x i16> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_u32 ={{.*}} global <16 x i32> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_u64 ={{.*}} global <8 x i64> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_f32 ={{.*}} global <16 x float> zeroinitializer, align 8
 // CHECK-512-NEXT: @global_f64 ={{.*}} global <8 x double> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i8m2 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i16m2 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i32m2 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i64m2 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u8m2 ={{.*}} global <128 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u16m2 ={{.*}} global <64 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u32m2 ={{.*}} global <32 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u64m2 ={{.*}} global <16 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f32m2 ={{.*}} global <32 x float> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f64m2 ={{.*}} global <16 x double> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i8m4 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i16m4 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i32m4 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i64m4 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u8m4 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u16m4 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u32m4 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u64m4 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f32m4 ={{.*}} global <64 x float> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f64m4 ={{.*}} global <32 x double> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i8m8 ={{.*}} global <512 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i16m8 ={{.*}} global <256 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i32m8 ={{.*}} global <128 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_i64m8 ={{.*}} global <64 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u8m8 ={{.*}} global <512 x i8> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u16m8 ={{.*}} global <256 x i16> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u32m8 ={{.*}} global <128 x i32> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_u64m8 ={{.*}} global <64 x i64> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f32m8 ={{.*}} global <128 x float> zeroinitializer, align 8
+// CHECK-512-NEXT: @global_f64m8 ={{.*}} global <64 x double> zeroinitializer, align 8
 
 // CHECK-1024:      @global_i8 ={{.*}} global <128 x i8> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_i16 ={{.*}} global <64 x i16> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_i32 ={{.*}} global <32 x i32> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_i64 ={{.*}} global <16 x i64> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_u8 ={{.*}} global <128 x i8> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_u16 ={{.*}} global <64 x i16> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_u32 ={{.*}} global <32 x i32> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_u64 ={{.*}} global <16 x i64> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_f32 ={{.*}} global <32 x float> zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_f64 ={{.*}} global <16 x double> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i8m2 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i16m2 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i32m2 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i64m2 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u8m2 ={{.*}} global <256 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u16m2 ={{.*}} global <128 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u32m2 ={{.*}} global <64 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u64m2 ={{.*}} global <32 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f32m2 ={{.*}} global <64 x float> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f64m2 ={{.*}} global <32 x double> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i8m4 ={{.*}} global <512 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i16m4 ={{.*}} global <256 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i32m4 ={{.*}} global <128 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i64m4 ={{.*}} global <64 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u8m4 ={{.*}} global <512 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u16m4 ={{.*}} global <256 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u32m4 ={{.*}} global <128 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u64m4 ={{.*}} global <64 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f32m4 ={{.*}} global <128 x float> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f64m4 ={{.*}} global <64 x double> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i8m8 ={{.*}} global <1024 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i16m8 ={{.*}} global <512 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i32m8 ={{.*}} global <256 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_i64m8 ={{.*}} global <128 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u8m8 ={{.*}} global <1024 x i8> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u16m8 ={{.*}} global <512 x i16> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u32m8 ={{.*}} global <256 x i32> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_u64m8 ={{.*}} global <128 x i64> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f32m8 ={{.*}} global <256 x float> zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_f64m8 ={{.*}} global <128 x double> zeroinitializer, align 8
 
 //===----------------------------------------------------------------------===//
 // Global arrays
 //===----------------------------------------------------------------------===//
 // CHECK-64:      @global_arr_i8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_i16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_i32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_i64 ={{.*}} global [3 x <1 x i64>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_u8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_u16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_u32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_u64 ={{.*}} global [3 x <1 x i64>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_f32 ={{.*}} global [3 x <2 x float>] zeroinitializer, align 8
 // CHECK-64-NEXT: @global_arr_f64 ={{.*}} global [3 x <1 x double>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i8m2 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i16m2 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i32m2 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i64m2 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u8m2 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u16m2 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u32m2 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u64m2 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f32m2 ={{.*}} global [3 x <4 x float>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f64m2 ={{.*}} global [3 x <2 x double>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i8m4 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i16m4 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i32m4 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i64m4 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u8m4 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u16m4 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u32m4 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u64m4 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f32m4 ={{.*}} global [3 x <8 x float>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f64m4 ={{.*}} global [3 x <4 x double>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i8m8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i16m8 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i32m8 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_i64m8 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u8m8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u16m8 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u32m8 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_u64m8 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f32m8 ={{.*}} global [3 x <16 x float>] zeroinitializer, align 8
+// CHECK-64-NEXT: @global_arr_f64m8 ={{.*}} global [3 x <8 x double>] zeroinitializer, align 8
 
 // CHECK-128:      @global_arr_i8 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_i16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_i32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_i64 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_u8 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_u16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_u32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_u64 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_f32 ={{.*}} global [3 x <4 x float>] zeroinitializer, align 8
 // CHECK-128-NEXT: @global_arr_f64 ={{.*}} global [3 x <2 x double>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i8m2 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i16m2 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i32m2 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i64m2 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u8m2 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u16m2 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u32m2 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u64m2 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f32m2 ={{.*}} global [3 x <8 x float>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f64m2 ={{.*}} global [3 x <4 x double>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i8m4 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i16m4 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i32m4 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i64m4 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u8m4 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u16m4 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u32m4 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u64m4 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f32m4 ={{.*}} global [3 x <16 x float>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f64m4 ={{.*}} global [3 x <8 x double>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i8m8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i16m8 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i32m8 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_i64m8 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u8m8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u16m8 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u32m8 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_u64m8 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f32m8 ={{.*}} global [3 x <32 x float>] zeroinitializer, align 8
+// CHECK-128-NEXT: @global_arr_f64m8 ={{.*}} global [3 x <16 x double>] zeroinitializer, align 8
 
 // CHECK-256:      @global_arr_i8 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_i16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_i32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_i64 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_u8 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_u16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_u32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_u64 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_f32 ={{.*}} global [3 x <8 x float>] zeroinitializer, align 8
 // CHECK-256-NEXT: @global_arr_f64 ={{.*}} global [3 x <4 x double>] zeroinitializer, align 8
-
+// CHECK-256-NEXT: @global_arr_i8m2 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i16m2 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i32m2 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i64m2 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u8m2 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u16m2 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u32m2 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u64m2 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f32m2 ={{.*}} global [3 x <16 x float>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f64m2 ={{.*}} global [3 x <8 x double>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i8m4 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i16m4 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i32m4 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i64m4 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u8m4 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u16m4 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u32m4 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u64m4 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f32m4 ={{.*}} global [3 x <32 x float>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f64m4 ={{.*}} global [3 x <16 x double>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i8m8 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i16m8 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i32m8 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_i64m8 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u8m8 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u16m8 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u32m8 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_u64m8 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f32m8 ={{.*}} global [3 x <64 x float>] zeroinitializer, align 8
+// CHECK-256-NEXT: @global_arr_f64m8 ={{.*}} global [3 x <32 x double>] zeroinitializer, align 8
 // CHECK-512:      @global_arr_i8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_i16 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_i32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_i64 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_u8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_u16 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_u32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_u64 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_f32 ={{.*}} global [3 x <16 x float>] zeroinitializer, align 8
 // CHECK-512-NEXT: @global_arr_f64 ={{.*}} global [3 x <8 x double>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i8m2 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i16m2 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i32m2 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i64m2 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u8m2 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u16m2 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u32m2 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u64m2 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f32m2 ={{.*}} global [3 x <32 x float>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f64m2 ={{.*}} global [3 x <16 x double>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i8m4 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i16m4 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i32m4 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i64m4 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u8m4 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u16m4 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u32m4 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u64m4 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f32m4 ={{.*}} global [3 x <64 x float>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f64m4 ={{.*}} global [3 x <32 x double>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i8m8 ={{.*}} global [3 x <512 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i16m8 ={{.*}} global [3 x <256 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i32m8 ={{.*}} global [3 x <128 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_i64m8 ={{.*}} global [3 x <64 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u8m8 ={{.*}} global [3 x <512 x i8>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u16m8 ={{.*}} global [3 x <256 x i16>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u32m8 ={{.*}} global [3 x <128 x i32>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_u64m8 ={{.*}} global [3 x <64 x i64>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f32m8 ={{.*}} global [3 x <128 x float>] zeroinitializer, align 8
+// CHECK-512-NEXT: @global_arr_f64m8 ={{.*}} global [3 x <64 x double>] zeroinitializer, align 8
 
 // CHECK-1024:      @global_arr_i8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_i16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_i32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_i64 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_u8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_u16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_u32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_u64 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_f32 ={{.*}} global [3 x <32 x float>] zeroinitializer, align 8
 // CHECK-1024-NEXT: @global_arr_f64 ={{.*}} global [3 x <16 x double>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i8m2 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i16m2 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i32m2 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i64m2 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u8m2 ={{.*}} global [3 x <256 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u16m2 ={{.*}} global [3 x <128 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u32m2 ={{.*}} global [3 x <64 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u64m2 ={{.*}} global [3 x <32 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f32m2 ={{.*}} global [3 x <64 x float>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f64m2 ={{.*}} global [3 x <32 x double>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i8m4 ={{.*}} global [3 x <512 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i16m4 ={{.*}} global [3 x <256 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i32m4 ={{.*}} global [3 x <128 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i64m4 ={{.*}} global [3 x <64 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u8m4 ={{.*}} global [3 x <512 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u16m4 ={{.*}} global [3 x <256 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u32m4 ={{.*}} global [3 x <128 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u64m4 ={{.*}} global [3 x <64 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f32m4 ={{.*}} global [3 x <128 x float>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f64m4 ={{.*}} global [3 x <64 x double>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i8m8 ={{.*}} global [3 x <1024 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i16m8 ={{.*}} global [3 x <512 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i32m8 ={{.*}} global [3 x <256 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_i64m8 ={{.*}} global [3 x <128 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u8m8 ={{.*}} global [3 x <1024 x i8>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u16m8 ={{.*}} global [3 x <512 x i16>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u32m8 ={{.*}} global [3 x <256 x i32>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_u64m8 ={{.*}} global [3 x <128 x i64>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f32m8 ={{.*}} global [3 x <256 x float>] zeroinitializer, align 8
+// CHECK-1024-NEXT: @global_arr_f64m8 ={{.*}} global [3 x <128 x double>] zeroinitializer, align 8
 
 //===----------------------------------------------------------------------===//
 // Local variables
 //===----------------------------------------------------------------------===//
 // CHECK-64:      %local_i8 = alloca <8 x i8>, align 8
 // CHECK-64-NEXT: %local_i16 = alloca <4 x i16>, align 8
 // CHECK-64-NEXT: %local_i32 = alloca <2 x i32>, align 8
 // CHECK-64-NEXT: %local_i64 = alloca <1 x i64>, align 8
 // CHECK-64-NEXT: %local_u8 = alloca <8 x i8>, align 8
 // CHECK-64-NEXT: %local_u16 = alloca <4 x i16>, align 8
 // CHECK-64-NEXT: %local_u32 = alloca <2 x i32>, align 8
 // CHECK-64-NEXT: %local_u64 = alloca <1 x i64>, align 8
 // CHECK-64-NEXT: %local_f32 = alloca <2 x float>, align 8
 // CHECK-64-NEXT: %local_f64 = alloca <1 x double>, align 8
+// CHECK-64-NEXT: %local_i8m2 = alloca <16 x i8>, align 8
+// CHECK-64-NEXT: %local_i16m2 = alloca <8 x i16>, align 8
+// CHECK-64-NEXT: %local_i32m2 = alloca <4 x i32>, align 8
+// CHECK-64-NEXT: %local_i64m2 = alloca <2 x i64>, align 8
+// CHECK-64-NEXT: %local_u8m2 = alloca <16 x i8>, align 8
+// CHECK-64-NEXT: %local_u16m2 = alloca <8 x i16>, align 8
+// CHECK-64-NEXT: %local_u32m2 = alloca <4 x i32>, align 8
+// CHECK-64-NEXT: %local_u64m2 = alloca <2 x i64>, align 8
+// CHECK-64-NEXT: %local_f32m2 = alloca <4 x float>, align 8
+// CHECK-64-NEXT: %local_f64m2 = alloca <2 x double>, align 8
+// CHECK-64-NEXT: %local_i8m4 = alloca <32 x i8>, align 8
+// CHECK-64-NEXT: %local_i16m4 = alloca <16 x i16>, align 8
+// CHECK-64-NEXT: %local_i32m4 = alloca <8 x i32>, align 8
+// CHECK-64-NEXT: %local_i64m4 = alloca <4 x i64>, align 8
+// CHECK-64-NEXT: %local_u8m4 = alloca <32 x i8>, align 8
+// CHECK-64-NEXT: %local_u16m4 = alloca <16 x i16>, align 8
+// CHECK-64-NEXT: %local_u32m4 = alloca <8 x i32>, align 8
+// CHECK-64-NEXT: %local_u64m4 = alloca <4 x i64>, align 8
+// CHECK-64-NEXT: %local_f32m4 = alloca <8 x float>, align 8
+// CHECK-64-NEXT: %local_f64m4 = alloca <4 x double>, align 8
+// CHECK-64-NEXT: %local_i8m8 = alloca <64 x i8>, align 8
+// CHECK-64-NEXT: %local_i16m8 = alloca <32 x i16>, align 8
+// CHECK-64-NEXT: %local_i32m8 = alloca <16 x i32>, align 8
+// CHECK-64-NEXT: %local_i64m8 = alloca <8 x i64>, align 8
+// CHECK-64-NEXT: %local_u8m8 = alloca <64 x i8>, align 8
+// CHECK-64-NEXT: %local_u16m8 = alloca <32 x i16>, align 8
+// CHECK-64-NEXT: %local_u32m8 = alloca <16 x i32>, align 8
+// CHECK-64-NEXT: %local_u64m8 = alloca <8 x i64>, align 8
+// CHECK-64-NEXT: %local_f32m8 = alloca <16 x float>, align 8
+// CHECK-64-NEXT: %local_f64m8 = alloca <8 x double>, align 8
 
 // CHECK-128:      %local_i8 = alloca <16 x i8>, align 8
 // CHECK-128-NEXT: %local_i16 = alloca <8 x i16>, align 8
 // CHECK-128-NEXT: %local_i32 = alloca <4 x i32>, align 8
 // CHECK-128-NEXT: %local_i64 = alloca <2 x i64>, align 8
 // CHECK-128-NEXT: %local_u8 = alloca <16 x i8>, align 8
 // CHECK-128-NEXT: %local_u16 = alloca <8 x i16>, align 8
 // CHECK-128-NEXT: %local_u32 = alloca <4 x i32>, align 8
 // CHECK-128-NEXT: %local_u64 = alloca <2 x i64>, align 8
 // CHECK-128-NEXT: %local_f32 = alloca <4 x float>, align 8
 // CHECK-128-NEXT: %local_f64 = alloca <2 x double>, align 8
+// CHECK-128-NEXT: %local_i8m2 = alloca <32 x i8>, align 8
+// CHECK-128-NEXT: %local_i16m2 = alloca <16 x i16>, align 8
+// CHECK-128-NEXT: %local_i32m2 = alloca <8 x i32>, align 8
+// CHECK-128-NEXT: %local_i64m2 = alloca <4 x i64>, align 8
+// CHECK-128-NEXT: %local_u8m2 = alloca <32 x i8>, align 8
+// CHECK-128-NEXT: %local_u16m2 = alloca <16 x i16>, align 8
+// CHECK-128-NEXT: %local_u32m2 = alloca <8 x i32>, align 8
+// CHECK-128-NEXT: %local_u64m2 = alloca <4 x i64>, align 8
+// CHECK-128-NEXT: %local_f32m2 = alloca <8 x float>, align 8
+// CHECK-128-NEXT: %local_f64m2 = alloca <4 x double>, align 8
+// CHECK-128-NEXT: %local_i8m4 = alloca <64 x i8>, align 8
+// CHECK-128-NEXT: %local_i16m4 = alloca <32 x i16>, align 8
+// CHECK-128-NEXT: %local_i32m4 = alloca <16 x i32>, align 8
+// CHECK-128-NEXT: %local_i64m4 = alloca <8 x i64>, align 8
+// CHECK-128-NEXT: %local_u8m4 = alloca <64 x i8>, align 8
+// CHECK-128-NEXT: %local_u16m4 = alloca <32 x i16>, align 8
+// CHECK-128-NEXT: %local_u32m4 = alloca <16 x i32>, align 8
+// CHECK-128-NEXT: %local_u64m4 = alloca <8 x i64>, align 8
+// CHECK-128-NEXT: %local_f32m4 = alloca <16 x float>, align 8
+// CHECK-128-NEXT: %local_f64m4 = alloca <8 x double>, align 8
+// CHECK-128-NEXT: %local_i8m8 = alloca <128 x i8>, align 8
+// CHECK-128-NEXT: %local_i16m8 = alloca <64 x i16>, align 8
+// CHECK-128-NEXT: %local_i32m8 = alloca <32 x i32>, align 8
+// CHECK-128-NEXT: %local_i64m8 = alloca <16 x i64>, align 8
+// CHECK-128-NEXT: %local_u8m8 = alloca <128 x i8>, align 8
+// CHECK-128-NEXT: %local_u16m8 = alloca <64 x i16>, align 8
+// CHECK-128-NEXT: %local_u32m8 = alloca <32 x i32>, align 8
+// CHECK-128-NEXT: %local_u64m8 = alloca <16 x i64>, align 8
+// CHECK-128-NEXT: %local_f32m8 = alloca <32 x float>, align 8
+// CHECK-128-NEXT: %local_f64m8 = alloca <16 x double>, align 8
 
 // CHECK-256:      %local_i8 = alloca <32 x i8>, align 8
 // CHECK-256-NEXT: %local_i16 = alloca <16 x i16>, align 8
 // CHECK-256-NEXT: %local_i32 = alloca <8 x i32>, align 8
 // CHECK-256-NEXT: %local_i64 = alloca <4 x i64>, align 8
 // CHECK-256-NEXT: %local_u8 = alloca <32 x i8>, align 8
 // CHECK-256-NEXT: %local_u16 = alloca <16 x i16>, align 8
 // CHECK-256-NEXT: %local_u32 = alloca <8 x i32>, align 8
 // CHECK-256-NEXT: %local_u64 = alloca <4 x i64>, align 8
 // CHECK-256-NEXT: %local_f32 = alloca <8 x float>, align 8
 // CHECK-256-NEXT: %local_f64 = alloca <4 x double>, align 8
+// CHECK-256-NEXT: %local_i8m2 = alloca <64 x i8>, align 8
+// CHECK-256-NEXT: %local_i16m2 = alloca <32 x i16>, align 8
+// CHECK-256-NEXT: %local_i32m2 = alloca <16 x i32>, align 8
+// CHECK-256-NEXT: %local_i64m2 = alloca <8 x i64>, align 8
+// CHECK-256-NEXT: %local_u8m2 = alloca <64 x i8>, align 8
+// CHECK-256-NEXT: %local_u16m2 = alloca <32 x i16>, align 8
+// CHECK-256-NEXT: %local_u32m2 = alloca <16 x i32>, align 8
+// CHECK-256-NEXT: %local_u64m2 = alloca <8 x i64>, align 8
+// CHECK-256-NEXT: %local_f32m2 = alloca <16 x float>, align 8
+// CHECK-256-NEXT: %local_f64m2 = alloca <8 x double>, align 8
+// CHECK-256-NEXT: %local_i8m4 = alloca <128 x i8>, align 8
+// CHECK-256-NEXT: %local_i16m4 = alloca <64 x i16>, align 8
+// CHECK-256-NEXT: %local_i32m4 = alloca <32 x i32>, align 8
+// CHECK-256-NEXT: %local_i64m4 = alloca <16 x i64>, align 8
+// CHECK-256-NEXT: %local_u8m4 = alloca <128 x i8>, align 8
+// CHECK-256-NEXT: %local_u16m4 = alloca <64 x i16>, align 8
+// CHECK-256-NEXT: %local_u32m4 = alloca <32 x i32>, align 8
+// CHECK-256-NEXT: %local_u64m4 = alloca <16 x i64>, align 8
+// CHECK-256-NEXT: %local_f32m4 = alloca <32 x float>, align 8
+// CHECK-256-NEXT: %local_f64m4 = alloca <16 x double>, align 8
+// CHECK-256-NEXT: %local_i8m8 = alloca <256 x i8>, align 8
+// CHECK-256-NEXT: %local_i16m8 = alloca <128 x i16>, align 8
+// CHECK-256-NEXT: %local_i32m8 = alloca <64 x i32>, align 8
+// CHECK-256-NEXT: %local_i64m8 = alloca <32 x i64>, align 8
+// CHECK-256-NEXT: %local_u8m8 = alloca <256 x i8>, align 8
+// CHECK-256-NEXT: %local_u16m8 = alloca <128 x i16>, align 8
+// CHECK-256-NEXT: %local_u32m8 = alloca <64 x i32>, align 8
+// CHECK-256-NEXT: %local_u64m8 = alloca <32 x i64>, align 8
+// CHECK-256-NEXT: %local_f32m8 = alloca <64 x float>, align 8
+// CHECK-256-NEXT: %local_f64m8 = alloca <32 x double>, align 8
 
 // CHECK-512:      %local_i8 = alloca <64 x i8>, align 8
 // CHECK-512-NEXT: %local_i16 = alloca <32 x i16>, align 8
 // CHECK-512-NEXT: %local_i32 = alloca <16 x i32>, align 8
 // CHECK-512-NEXT: %local_i64 = alloca <8 x i64>, align 8
 // CHECK-512-NEXT: %local_u8 = alloca <64 x i8>, align 8
 // CHECK-512-NEXT: %local_u16 = alloca <32 x i16>, align 8
 // CHECK-512-NEXT: %local_u32 = alloca <16 x i32>, align 8
 // CHECK-512-NEXT: %local_u64 = alloca <8 x i64>, align 8
 // CHECK-512-NEXT: %local_f32 = alloca <16 x float>, align 8
 // CHECK-512-NEXT: %local_f64 = alloca <8 x double>, align 8
+// CHECK-512-NEXT: %local_i8m2 = alloca <128 x i8>, align 8
+// CHECK-512-NEXT: %local_i16m2 = alloca <64 x i16>, align 8
+// CHECK-512-NEXT: %local_i32m2 = alloca <32 x i32>, align 8
+// CHECK-512-NEXT: %local_i64m2 = alloca <16 x i64>, align 8
+// CHECK-512-NEXT: %local_u8m2 = alloca <128 x i8>, align 8
+// CHECK-512-NEXT: %local_u16m2 = alloca <64 x i16>, align 8
+// CHECK-512-NEXT: %local_u32m2 = alloca <32 x i32>, align 8
+// CHECK-512-NEXT: %local_u64m2 = alloca <16 x i64>, align 8
+// CHECK-512-NEXT: %local_f32m2 = alloca <32 x float>, align 8
+// CHECK-512-NEXT: %local_f64m2 = alloca <16 x double>, align 8
+// CHECK-512-NEXT: %local_i8m4 = alloca <256 x i8>, align 8
+// CHECK-512-NEXT: %local_i16m4 = alloca <128 x i16>, align 8
+// CHECK-512-NEXT: %local_i32m4 = alloca <64 x i32>, align 8
+// CHECK-512-NEXT: %local_i64m4 = alloca <32 x i64>, align 8
+// CHECK-512-NEXT: %local_u8m4 = alloca <256 x i8>, align 8
+// CHECK-512-NEXT: %local_u16m4 = alloca <128 x i16>, align 8
+// CHECK-512-NEXT: %local_u32m4 = alloca <64 x i32>, align 8
+// CHECK-512-NEXT: %local_u64m4 = alloca <32 x i64>, align 8
+// CHECK-512-NEXT: %local_f32m4 = alloca <64 x float>, align 8
+// CHECK-512-NEXT: %local_f64m4 = alloca <32 x double>, align 8
+// CHECK-512-NEXT: %local_i8m8 = alloca <512 x i8>, align 8
+// CHECK-512-NEXT: %local_i16m8 = alloca <256 x i16>, align 8
+// CHECK-512-NEXT: %local_i32m8 = alloca <128 x i32>, align 8
+// CHECK-512-NEXT: %local_i64m8 = alloca <64 x i64>, align 8
+// CHECK-512-NEXT: %local_u8m8 = alloca <512 x i8>, align 8
+// CHECK-512-NEXT: %local_u16m8 = alloca <256 x i16>, align 8
+// CHECK-512-NEXT: %local_u32m8 = alloca <128 x i32>, align 8
+// CHECK-512-NEXT: %local_u64m8 = alloca <64 x i64>, align 8
+// CHECK-512-NEXT: %local_f32m8 = alloca <128 x float>, align 8
+// CHECK-512-NEXT: %local_f64m8 = alloca <64 x double>, align 8
 
 // CHECK-1024:       %local_i8 = alloca <128 x i8>, align 8
 // CHECK-1024-NEXT:  %local_i16 = alloca <64 x i16>, align 8
 // CHECK-1024-NEXT:  %local_i32 = alloca <32 x i32>, align 8
 // CHECK-1024-NEXT:  %local_i64 = alloca <16 x i64>, align 8
 // CHECK-1024-NEXT:  %local_u8 = alloca <128 x i8>, align 8
 // CHECK-1024-NEXT:  %local_u16 = alloca <64 x i16>, align 8
 // CHECK-1024-NEXT:  %local_u32 = alloca <32 x i32>, align 8
 // CHECK-1024-NEXT:  %local_u64 = alloca <16 x i64>, align 8
 // CHECK-1024-NEXT:  %local_f32 = alloca <32 x float>, align 8
 // CHECK-1024-NEXT:  %local_f64 = alloca <16 x double>, align 8
+// CHECK-1024-NEXT:  %local_i8m2 = alloca <256 x i8>, align 8
+// CHECK-1024-NEXT:  %local_i16m2 = alloca <128 x i16>, align 8
+// CHECK-1024-NEXT:  %local_i32m2 = alloca <64 x i32>, align 8
+// CHECK-1024-NEXT:  %local_i64m2 = alloca <32 x i64>, align 8
+// CHECK-1024-NEXT:  %local_u8m2 = alloca <256 x i8>, align 8
+// CHECK-1024-NEXT:  %local_u16m2 = alloca <128 x i16>, align 8
+// CHECK-1024-NEXT:  %local_u32m2 = alloca <64 x i32>, align 8
+// CHECK-1024-NEXT:  %local_u64m2 = alloca <32 x i64>, align 8
+// CHECK-1024-NEXT:  %local_f32m2 = alloca <64 x float>, align 8
+// CHECK-1024-NEXT:  %local_f64m2 = alloca <32 x double>, align 8
+// CHECK-1024-NEXT:  %local_i8m4 = alloca <512 x i8>, align 8
+// CHECK-1024-NEXT:  %local_i16m4 = alloca <256 x i16>, align 8
+// CHECK-1024-NEXT:  %local_i32m4 = alloca <128 x i32>, align 8
+// CHECK-1024-NEXT:  %local_i64m4 = alloca <64 x i64>, align 8
+// CHECK-1024-NEXT:  %local_u8m4 = alloca <512 x i8>, align 8
+// CHECK-1024-NEXT:  %local_u16m4 = alloca <256 x i16>, align 8
+// CHECK-1024-NEXT:  %local_u32m4 = alloca <128 x i32>, align 8
+// CHECK-1024-NEXT:  %local_u64m4 = alloca <64 x i64>, align 8
+// CHECK-1024-NEXT:  %local_f32m4 = alloca <128 x float>, align 8
+// CHECK-1024-NEXT:  %local_f64m4 = alloca <64 x double>, align 8
+// CHECK-1024-NEXT:  %local_i8m8 = alloca <1024 x i8>, align 8
+// CHECK-1024-NEXT:  %local_i16m8 = alloca <512 x i16>, align 8
+// CHECK-1024-NEXT:  %local_i32m8 = alloca <256 x i32>, align 8
+// CHECK-1024-NEXT:  %local_i64m8 = alloca <128 x i64>, align 8
+// CHECK-1024-NEXT:  %local_u8m8 = alloca <1024 x i8>, align 8
+// CHECK-1024-NEXT:  %local_u16m8 = alloca <512 x i16>, align 8
+// CHECK-1024-NEXT:  %local_u32m8 = alloca <256 x i32>, align 8
+// CHECK-1024-NEXT:  %local_u64m8 = alloca <128 x i64>, align 8
+// CHECK-1024-NEXT:  %local_f32m8 = alloca <256 x float>, align 8
+// CHECK-1024-NEXT:  %local_f64m8 = alloca <128 x double>, align 8
 
 //===----------------------------------------------------------------------===//
 // Local arrays
 //===----------------------------------------------------------------------===//
 // CHECK-64:      %local_arr_i8 = alloca [3 x <8 x i8>], align 8
 // CHECK-64-NEXT: %local_arr_i16 = alloca [3 x <4 x i16>], align 8
 // CHECK-64-NEXT: %local_arr_i32 = alloca [3 x <2 x i32>], align 8
 // CHECK-64-NEXT: %local_arr_i64 = alloca [3 x <1 x i64>], align 8
 // CHECK-64-NEXT: %local_arr_u8 = alloca [3 x <8 x i8>], align 8
 // CHECK-64-NEXT: %local_arr_u16 = alloca [3 x <4 x i16>], align 8
 // CHECK-64-NEXT: %local_arr_u32 = alloca [3 x <2 x i32>], align 8
 // CHECK-64-NEXT: %local_arr_u64 = alloca [3 x <1 x i64>], align 8
 // CHECK-64-NEXT: %local_arr_f32 = alloca [3 x <2 x float>], align 8
 // CHECK-64-NEXT: %local_arr_f64 = alloca [3 x <1 x double>], align 8
+// CHECK-64-NEXT: %local_arr_i8m2 = alloca [3 x <16 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_i16m2 = alloca [3 x <8 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_i32m2 = alloca [3 x <4 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_i64m2 = alloca [3 x <2 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_u8m2 = alloca [3 x <16 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_u16m2 = alloca [3 x <8 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_u32m2 = alloca [3 x <4 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_u64m2 = alloca [3 x <2 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_f32m2 = alloca [3 x <4 x float>], align 8
+// CHECK-64-NEXT: %local_arr_f64m2 = alloca [3 x <2 x double>], align 8
+// CHECK-64-NEXT: %local_arr_i8m4 = alloca [3 x <32 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_i16m4 = alloca [3 x <16 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_i32m4 = alloca [3 x <8 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_i64m4 = alloca [3 x <4 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_u8m4 = alloca [3 x <32 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_u16m4 = alloca [3 x <16 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_u32m4 = alloca [3 x <8 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_u64m4 = alloca [3 x <4 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_f32m4 = alloca [3 x <8 x float>], align 8
+// CHECK-64-NEXT: %local_arr_f64m4 = alloca [3 x <4 x double>], align 8
+// CHECK-64-NEXT: %local_arr_i8m8 = alloca [3 x <64 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_i16m8 = alloca [3 x <32 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_i32m8 = alloca [3 x <16 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_i64m8 = alloca [3 x <8 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_u8m8 = alloca [3 x <64 x i8>], align 8
+// CHECK-64-NEXT: %local_arr_u16m8 = alloca [3 x <32 x i16>], align 8
+// CHECK-64-NEXT: %local_arr_u32m8 = alloca [3 x <16 x i32>], align 8
+// CHECK-64-NEXT: %local_arr_u64m8 = alloca [3 x <8 x i64>], align 8
+// CHECK-64-NEXT: %local_arr_f32m8 = alloca [3 x <16 x float>], align 8
+// CHECK-64-NEXT: %local_arr_f64m8 = alloca [3 x <8 x double>], align 8
 
 // CHECK-128:      %local_arr_i8 = alloca [3 x <16 x i8>], align 8
 // CHECK-128-NEXT: %local_arr_i16 = alloca [3 x <8 x i16>], align 8
 // CHECK-128-NEXT: %local_arr_i32 = alloca [3 x <4 x i32>], align 8
 // CHECK-128-NEXT: %local_arr_i64 = alloca [3 x <2 x i64>], align 8
 // CHECK-128-NEXT: %local_arr_u8 = alloca [3 x <16 x i8>], align 8
 // CHECK-128-NEXT: %local_arr_u16 = alloca [3 x <8 x i16>], align 8
 // CHECK-128-NEXT: %local_arr_u32 = alloca [3 x <4 x i32>], align 8
 // CHECK-128-NEXT: %local_arr_u64 = alloca [3 x <2 x i64>], align 8
 // CHECK-128-NEXT: %local_arr_f32 = alloca [3 x <4 x float>], align 8
 // CHECK-128-NEXT: %local_arr_f64 = alloca [3 x <2 x double>], align 8
+// CHECK-128-NEXT: %local_arr_i8m2 = alloca [3 x <32 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_i16m2 = alloca [3 x <16 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_i32m2 = alloca [3 x <8 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_i64m2 = alloca [3 x <4 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_u8m2 = alloca [3 x <32 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_u16m2 = alloca [3 x <16 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_u32m2 = alloca [3 x <8 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_u64m2 = alloca [3 x <4 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_f32m2 = alloca [3 x <8 x float>], align 8
+// CHECK-128-NEXT: %local_arr_f64m2 = alloca [3 x <4 x double>], align 8
+// CHECK-128-NEXT: %local_arr_i8m4 = alloca [3 x <64 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_i16m4 = alloca [3 x <32 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_i32m4 = alloca [3 x <16 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_i64m4 = alloca [3 x <8 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_u8m4 = alloca [3 x <64 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_u16m4 = alloca [3 x <32 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_u32m4 = alloca [3 x <16 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_u64m4 = alloca [3 x <8 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_f32m4 = alloca [3 x <16 x float>], align 8
+// CHECK-128-NEXT: %local_arr_f64m4 = alloca [3 x <8 x double>], align 8
+// CHECK-128-NEXT: %local_arr_i8m8 = alloca [3 x <128 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_i16m8 = alloca [3 x <64 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_i32m8 = alloca [3 x <32 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_i64m8 = alloca [3 x <16 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_u8m8 = alloca [3 x <128 x i8>], align 8
+// CHECK-128-NEXT: %local_arr_u16m8 = alloca [3 x <64 x i16>], align 8
+// CHECK-128-NEXT: %local_arr_u32m8 = alloca [3 x <32 x i32>], align 8
+// CHECK-128-NEXT: %local_arr_u64m8 = alloca [3 x <16 x i64>], align 8
+// CHECK-128-NEXT: %local_arr_f32m8 = alloca [3 x <32 x float>], align 8
+// CHECK-128-NEXT: %local_arr_f64m8 = alloca [3 x <16 x double>], align 8
 
 // CHECK-256:      %local_arr_i8 = alloca [3 x <32 x i8>], align 8
 // CHECK-256-NEXT: %local_arr_i16 = alloca [3 x <16 x i16>], align 8
 // CHECK-256-NEXT: %local_arr_i32 = alloca [3 x <8 x i32>], align 8
 // CHECK-256-NEXT: %local_arr_i64 = alloca [3 x <4 x i64>], align 8
 // CHECK-256-NEXT: %local_arr_u8 = alloca [3 x <32 x i8>], align 8
 // CHECK-256-NEXT: %local_arr_u16 = alloca [3 x <16 x i16>], align 8
 // CHECK-256-NEXT: %local_arr_u32 = alloca [3 x <8 x i32>], align 8
 // CHECK-256-NEXT: %local_arr_u64 = alloca [3 x <4 x i64>], align 8
 // CHECK-256-NEXT: %local_arr_f32 = alloca [3 x <8 x float>], align 8
 // CHECK-256-NEXT: %local_arr_f64 = alloca [3 x <4 x double>], align 8
+// CHECK-256-NEXT: %local_arr_i8m2 = alloca [3 x <64 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_i16m2 = alloca [3 x <32 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_i32m2 = alloca [3 x <16 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_i64m2 = alloca [3 x <8 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_u8m2 = alloca [3 x <64 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_u16m2 = alloca [3 x <32 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_u32m2 = alloca [3 x <16 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_u64m2 = alloca [3 x <8 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_f32m2 = alloca [3 x <16 x float>], align 8
+// CHECK-256-NEXT: %local_arr_f64m2 = alloca [3 x <8 x double>], align 8
+// CHECK-256-NEXT: %local_arr_i8m4 = alloca [3 x <128 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_i16m4 = alloca [3 x <64 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_i32m4 = alloca [3 x <32 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_i64m4 = alloca [3 x <16 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_u8m4 = alloca [3 x <128 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_u16m4 = alloca [3 x <64 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_u32m4 = alloca [3 x <32 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_u64m4 = alloca [3 x <16 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_f32m4 = alloca [3 x <32 x float>], align 8
+// CHECK-256-NEXT: %local_arr_f64m4 = alloca [3 x <16 x double>], align 8
+// CHECK-256-NEXT: %local_arr_i8m8 = alloca [3 x <256 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_i16m8 = alloca [3 x <128 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_i32m8 = alloca [3 x <64 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_i64m8 = alloca [3 x <32 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_u8m8 = alloca [3 x <256 x i8>], align 8
+// CHECK-256-NEXT: %local_arr_u16m8 = alloca [3 x <128 x i16>], align 8
+// CHECK-256-NEXT: %local_arr_u32m8 = alloca [3 x <64 x i32>], align 8
+// CHECK-256-NEXT: %local_arr_u64m8 = alloca [3 x <32 x i64>], align 8
+// CHECK-256-NEXT: %local_arr_f32m8 = alloca [3 x <64 x float>], align 8
+// CHECK-256-NEXT: %local_arr_f64m8 = alloca [3 x <32 x double>], align 8
 
 // CHECK-512:      %local_arr_i8 = alloca [3 x <64 x i8>], align 8
 // CHECK-512-NEXT: %local_arr_i16 = alloca [3 x <32 x i16>], align 8
 // CHECK-512-NEXT: %local_arr_i32 = alloca [3 x <16 x i32>], align 8
 // CHECK-512-NEXT: %local_arr_i64 = alloca [3 x <8 x i64>], align 8
 // CHECK-512-NEXT: %local_arr_u8 = alloca [3 x <64 x i8>], align 8
 // CHECK-512-NEXT: %local_arr_u16 = alloca [3 x <32 x i16>], align 8
 // CHECK-512-NEXT: %local_arr_u32 = alloca [3 x <16 x i32>], align 8
 // CHECK-512-NEXT: %local_arr_u64 = alloca [3 x <8 x i64>], align 8
 // CHECK-512-NEXT: %local_arr_f32 = alloca [3 x <16 x float>], align 8
 // CHECK-512-NEXT: %local_arr_f64 = alloca [3 x <8 x double>], align 8
+// CHECK-512-NEXT: %local_arr_i8m2 = alloca [3 x <128 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_i16m2 = alloca [3 x <64 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_i32m2 = alloca [3 x <32 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_i64m2 = alloca [3 x <16 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_u8m2 = alloca [3 x <128 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_u16m2 = alloca [3 x <64 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_u32m2 = alloca [3 x <32 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_u64m2 = alloca [3 x <16 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_f32m2 = alloca [3 x <32 x float>], align 8
+// CHECK-512-NEXT: %local_arr_f64m2 = alloca [3 x <16 x double>], align 8
+// CHECK-512-NEXT: %local_arr_i8m4 = alloca [3 x <256 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_i16m4 = alloca [3 x <128 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_i32m4 = alloca [3 x <64 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_i64m4 = alloca [3 x <32 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_u8m4 = alloca [3 x <256 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_u16m4 = alloca [3 x <128 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_u32m4 = alloca [3 x <64 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_u64m4 = alloca [3 x <32 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_f32m4 = alloca [3 x <64 x float>], align 8
+// CHECK-512-NEXT: %local_arr_f64m4 = alloca [3 x <32 x double>], align 8
+// CHECK-512-NEXT: %local_arr_i8m8 = alloca [3 x <512 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_i16m8 = alloca [3 x <256 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_i32m8 = alloca [3 x <128 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_i64m8 = alloca [3 x <64 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_u8m8 = alloca [3 x <512 x i8>], align 8
+// CHECK-512-NEXT: %local_arr_u16m8 = alloca [3 x <256 x i16>], align 8
+// CHECK-512-NEXT: %local_arr_u32m8 = alloca [3 x <128 x i32>], align 8
+// CHECK-512-NEXT: %local_arr_u64m8 = alloca [3 x <64 x i64>], align 8
+// CHECK-512-NEXT: %local_arr_f32m8 = alloca [3 x <128 x float>], align 8
+// CHECK-512-NEXT: %local_arr_f64m8 = alloca [3 x <64 x double>], align 8
 
 // CHECK-1024:       %local_arr_i8 = alloca [3 x <128 x i8>], align 8
 // CHECK-1024-NEXT:  %local_arr_i16 = alloca [3 x <64 x i16>], align 8
 // CHECK-1024-NEXT:  %local_arr_i32 = alloca [3 x <32 x i32>], align 8
 // CHECK-1024-NEXT:  %local_arr_i64 = alloca [3 x <16 x i64>], align 8
 // CHECK-1024-NEXT:  %local_arr_u8 = alloca [3 x <128 x i8>], align 8
 // CHECK-1024-NEXT:  %local_arr_u16 = alloca [3 x <64 x i16>], align 8
 // CHECK-1024-NEXT:  %local_arr_u32 = alloca [3 x <32 x i32>], align 8
 // CHECK-1024-NEXT:  %local_arr_u64 = alloca [3 x <16 x i64>], align 8
 // CHECK-1024-NEXT:  %local_arr_f32 = alloca [3 x <32 x float>], align 8
 // CHECK-1024-NEXT:  %local_arr_f64 = alloca [3 x <16 x double>], align 8
+// CHECK-1024-NEXT:  %local_arr_i8m2 = alloca [3 x <256 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_i16m2 = alloca [3 x <128 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_i32m2 = alloca [3 x <64 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_i64m2 = alloca [3 x <32 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_u8m2 = alloca [3 x <256 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_u16m2 = alloca [3 x <128 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_u32m2 = alloca [3 x <64 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_u64m2 = alloca [3 x <32 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_f32m2 = alloca [3 x <64 x float>], align 8
+// CHECK-1024-NEXT:  %local_arr_f64m2 = alloca [3 x <32 x double>], align 8
+// CHECK-1024-NEXT:  %local_arr_i8m4 = alloca [3 x <512 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_i16m4 = alloca [3 x <256 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_i32m4 = alloca [3 x <128 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_i64m4 = alloca [3 x <64 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_u8m4 = alloca [3 x <512 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_u16m4 = alloca [3 x <256 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_u32m4 = alloca [3 x <128 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_u64m4 = alloca [3 x <64 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_f32m4 = alloca [3 x <128 x float>], align 8
+// CHECK-1024-NEXT:  %local_arr_f64m4 = alloca [3 x <64 x double>], align 8
+// CHECK-1024-NEXT:  %local_arr_i8m8 = alloca [3 x <1024 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_i16m8 = alloca [3 x <512 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_i32m8 = alloca [3 x <256 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_i64m8 = alloca [3 x <128 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_u8m8 = alloca [3 x <1024 x i8>], align 8
+// CHECK-1024-NEXT:  %local_arr_u16m8 = alloca [3 x <512 x i16>], align 8
+// CHECK-1024-NEXT:  %local_arr_u32m8 = alloca [3 x <256 x i32>], align 8
+// CHECK-1024-NEXT:  %local_arr_u64m8 = alloca [3 x <128 x i64>], align 8
+// CHECK-1024-NEXT:  %local_arr_f32m8 = alloca [3 x <256 x float>], align 8
+// CHECK-1024-NEXT:  %local_arr_f64m8 = alloca [3 x <128 x double>], align 8

clang/test/Driver/riscv-rvv-vector-bits.c

 
 // Error if attribute vector size != -mrvv-vector-bits
 // -----------------------------------------------------------------------------
 // RUN: not %clang -c %s -o /dev/null -target riscv64-linux-gnu \
 // RUN:  -march=rv64gc_zve64x -mrvv-vector-bits=128 2>&1 | FileCheck --check-prefix=CHECK-BAD-VECTOR-SIZE-ERROR %s
 
 typedef vint32_t bad_vector_size __attribute__((riscv_rvv_vector_bits(256)));
 
-// CHECK-BAD-VECTOR-SIZE-ERROR: error: invalid RVV vector size '256', must match value set by '-mrvv-vector-bits' ('128')
+// CHECK-BAD-VECTOR-SIZE-ERROR: error: invalid RVV vector size '256', expected size is '128' based on LMUL of type and '-mrvv-vector-bits'

clang/test/Sema/attr-riscv-rvv-vector-bits.c

 // RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +f -target-feature +d -target-feature +zve64d -ffreestanding -fsyntax-only -verify -mvscale-min=1 -mvscale-max=1 %s
 // RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +f -target-feature +d -target-feature +zve64d -ffreestanding -fsyntax-only -verify -mvscale-min=2 -mvscale-max=2 %s
 // RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +f -target-feature +d -target-feature +zve64d -ffreestanding -fsyntax-only -verify -mvscale-min=4 -mvscale-max=4 %s
 // RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +f -target-feature +d -target-feature +zve64d -ffreestanding -fsyntax-only -verify -mvscale-min=8 -mvscale-max=8 %s
 // RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +f -target-feature +d -target-feature +zve64d -ffreestanding -fsyntax-only -verify -mvscale-min=16 -mvscale-max=16 %s
 
 #include <stdint.h>
 
+typedef __rvv_int8mf8_t vint8mf8_t;
+typedef __rvv_uint8mf8_t vuint8mf8_t;
+
+typedef __rvv_int8mf4_t vint8mf4_t;
+typedef __rvv_uint8mf4_t vuint8mf4_t;
+typedef __rvv_int16mf4_t vint16mf4_t;
+typedef __rvv_uint16mf4_t vuint16mf4_t;
+
+typedef __rvv_int8mf2_t vint8mf2_t;
+typedef __rvv_uint8mf2_t vuint8mf2_t;
+typedef __rvv_int16mf2_t vint16mf2_t;
+typedef __rvv_uint16mf2_t vuint16mf2_t;
+typedef __rvv_int32mf2_t vint32mf2_t;
+typedef __rvv_uint32mf2_t vuint32mf2_t;
+typedef __rvv_float32mf2_t vfloat32mf2_t;
+
 typedef __rvv_int8m1_t vint8m1_t;
 typedef __rvv_uint8m1_t vuint8m1_t;
 typedef __rvv_int16m1_t vint16m1_t;
 typedef __rvv_uint16m1_t vuint16m1_t;
 typedef __rvv_int32m1_t vint32m1_t;
 typedef __rvv_uint32m1_t vuint32m1_t;
 typedef __rvv_int64m1_t vint64m1_t;
 typedef __rvv_uint64m1_t vuint64m1_t;
 typedef __rvv_float32m1_t vfloat32m1_t;
 typedef __rvv_float64m1_t vfloat64m1_t;
 
+typedef __rvv_int8m2_t vint8m2_t;
+typedef __rvv_uint8m2_t vuint8m2_t;
+typedef __rvv_int16m2_t vint16m2_t;
+typedef __rvv_uint16m2_t vuint16m2_t;
 typedef __rvv_int32m2_t vint32m2_t;
+typedef __rvv_uint32m2_t vuint32m2_t;
+typedef __rvv_int64m2_t vint64m2_t;
+typedef __rvv_uint64m2_t vuint64m2_t;
+typedef __rvv_float32m2_t vfloat32m2_t;
+typedef __rvv_float64m2_t vfloat64m2_t;
+
+typedef __rvv_int8m4_t vint8m4_t;
+typedef __rvv_uint8m4_t vuint8m4_t;
+typedef __rvv_int16m4_t vint16m4_t;
+typedef __rvv_uint16m4_t vuint16m4_t;
+typedef __rvv_int32m4_t vint32m4_t;
+typedef __rvv_uint32m4_t vuint32m4_t;
+typedef __rvv_int64m4_t vint64m4_t;
+typedef __rvv_uint64m4_t vuint64m4_t;
+typedef __rvv_float32m4_t vfloat32m4_t;
+typedef __rvv_float64m4_t vfloat64m4_t;
+
+typedef __rvv_int8m8_t vint8m8_t;
+typedef __rvv_uint8m8_t vuint8m8_t;
+typedef __rvv_int16m8_t vint16m8_t;
+typedef __rvv_uint16m8_t vuint16m8_t;
+typedef __rvv_int32m8_t vint32m8_t;
+typedef __rvv_uint32m8_t vuint32m8_t;
+typedef __rvv_int64m8_t vint64m8_t;
+typedef __rvv_uint64m8_t vuint64m8_t;
+typedef __rvv_float32m8_t vfloat32m8_t;
+typedef __rvv_float64m8_t vfloat64m8_t;
 
 // Define valid fixed-width RVV types
+typedef vint8mf8_t fixed_int8mf8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 8)));
+
+typedef vuint8mf8_t fixed_uint8mf8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 8)));
+
+typedef vint8mf4_t fixed_int8mf4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 4)));
+typedef vint16mf4_t fixed_int16mf4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 4)));
+
+typedef vuint8mf4_t fixed_uint8mf4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 4)));
+typedef vuint16mf4_t fixed_uint16mf4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 4)));
+
+typedef vint8mf2_t fixed_int8mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+typedef vint16mf2_t fixed_int16mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+typedef vint32mf2_t fixed_int32mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+
+typedef vuint8mf2_t fixed_uint8mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+typedef vuint16mf2_t fixed_uint16mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+typedef vuint32mf2_t fixed_uint32mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+
+typedef vfloat32mf2_t fixed_float32mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2)));
+
 typedef vint8m1_t fixed_int8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint16m1_t fixed_int16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
 typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
 typedef vfloat32m1_t fixed_float32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vfloat64m1_t fixed_float64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
+typedef vint8m2_t fixed_int8m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint16m2_t fixed_int16m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint32m2_t fixed_int32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vint64m2_t fixed_int64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vuint8m2_t fixed_uint8m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint16m2_t fixed_uint16m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint32m2_t fixed_uint32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vuint64m2_t fixed_uint64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vfloat32m2_t fixed_float32m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vfloat64m2_t fixed_float64m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vint8m4_t fixed_int8m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint16m4_t fixed_int16m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint32m4_t fixed_int32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vint64m4_t fixed_int64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vuint8m4_t fixed_uint8m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint16m4_t fixed_uint16m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint32m4_t fixed_uint32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vuint64m4_t fixed_uint64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vfloat32m4_t fixed_float32m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vfloat64m4_t fixed_float64m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vint8m8_t fixed_int8m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint16m8_t fixed_int16m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint32m8_t fixed_int32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vint64m8_t fixed_int64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
+typedef vuint8m8_t fixed_uint8m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint16m8_t fixed_uint16m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint32m8_t fixed_uint32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vuint64m8_t fixed_uint64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
+typedef vfloat32m8_t fixed_float32m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vfloat64m8_t fixed_float64m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
 // GNU vector types
+typedef int8_t gnu_int8mf8_t __attribute__((vector_size(__riscv_v_fixed_vlen / 64)));
+
+typedef uint8_t gnu_uint8mf8_t __attribute__((vector_size(__riscv_v_fixed_vlen / 64)));
+
+typedef int8_t gnu_int8mf4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 32)));
+typedef int16_t gnu_int16mf4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 32)));
+
+typedef uint8_t gnu_uint8mf4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 32)));
+typedef uint16_t gnu_uint16mf4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 32)));
+
+typedef int8_t gnu_int8mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+typedef int16_t gnu_int16mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+typedef int32_t gnu_int32mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+
+typedef uint8_t gnu_uint8mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+typedef uint16_t gnu_uint16mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+typedef uint32_t gnu_uint32mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+
+typedef float gnu_float32mf2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 16)));
+
 typedef int8_t gnu_int8m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef int16_t gnu_int16m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef int32_t gnu_int32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef int64_t gnu_int64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 
 typedef uint8_t gnu_uint8m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef uint16_t gnu_uint16m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef uint32_t gnu_uint32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef uint64_t gnu_uint64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 
 typedef float gnu_float32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 typedef double gnu_float64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
 
-typedef int32_t gnu_int32m2_t __attribute__((vector_size((__riscv_v_fixed_vlen * 2) / 8)));
+typedef int8_t gnu_int8m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef int16_t gnu_int16m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef int32_t gnu_int32m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef int64_t gnu_int64m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+
+typedef uint8_t gnu_uint8m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef uint16_t gnu_uint16m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef uint32_t gnu_uint32m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef uint64_t gnu_uint64m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+
+typedef float gnu_float32m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+typedef double gnu_float64m2_t __attribute__((vector_size(__riscv_v_fixed_vlen / 4)));
+
+typedef int8_t gnu_int8m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef int16_t gnu_int16m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef int32_t gnu_int32m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef int64_t gnu_int64m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+
+typedef uint8_t gnu_uint8m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef uint16_t gnu_uint16m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef uint32_t gnu_uint32m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef uint64_t gnu_uint64m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+
+typedef float gnu_float32m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+typedef double gnu_float64m4_t __attribute__((vector_size(__riscv_v_fixed_vlen / 2)));
+
+typedef int8_t gnu_int8m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef int16_t gnu_int16m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef int32_t gnu_int32m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef int64_t gnu_int64m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+
+typedef uint8_t gnu_uint8m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef uint16_t gnu_uint16m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef uint32_t gnu_uint32m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef uint64_t gnu_uint64m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+
+typedef float gnu_float32m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
+typedef double gnu_float64m8_t __attribute__((vector_size(__riscv_v_fixed_vlen)));
 
 // Attribute must have a single argument
 typedef vint8m1_t no_argument __attribute__((riscv_rvv_vector_bits));         // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}}
 typedef vint8m1_t two_arguments __attribute__((riscv_rvv_vector_bits(2, 4))); // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}}
 
 // The number of RVV vector bits must be an integer constant expression
 typedef vint8m1_t non_int_size1 __attribute__((riscv_rvv_vector_bits(2.0)));   // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}}
 typedef vint8m1_t non_int_size2 __attribute__((riscv_rvv_vector_bits("256"))); // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}}
void f(int c) {
   gs8 = gs8 & fs8; // expected-error {{cannot combine GNU and RVV vectors in expression, result is ambiguous}}
 }
 
 // --------------------------------------------------------------------------//
 // Sizeof
 
 #define VECTOR_SIZE ((__riscv_v_fixed_vlen / 8))
 
+_Static_assert(sizeof(fixed_int8mf8_t) == VECTOR_SIZE / 8, "");
+
+_Static_assert(sizeof(fixed_uint8mf8_t) == VECTOR_SIZE / 8, "");
+
+_Static_assert(sizeof(fixed_int8mf4_t) == VECTOR_SIZE / 4, "");
+_Static_assert(sizeof(fixed_int16mf4_t) == VECTOR_SIZE / 4, "");
+
+_Static_assert(sizeof(fixed_uint8mf4_t) == VECTOR_SIZE / 4, "");
+_Static_assert(sizeof(fixed_uint16mf4_t) == VECTOR_SIZE / 4, "");
+
+_Static_assert(sizeof(fixed_int8mf2_t) == VECTOR_SIZE / 2, "");
+_Static_assert(sizeof(fixed_int16mf2_t) == VECTOR_SIZE / 2, "");
+_Static_assert(sizeof(fixed_int32mf2_t) == VECTOR_SIZE / 2, "");
+
+_Static_assert(sizeof(fixed_uint8mf2_t) == VECTOR_SIZE / 2, "");
+_Static_assert(sizeof(fixed_uint16mf2_t) == VECTOR_SIZE / 2, "");
+_Static_assert(sizeof(fixed_uint32mf2_t) == VECTOR_SIZE / 2, "");
+
+_Static_assert(sizeof(fixed_float32mf2_t) == VECTOR_SIZE / 2, "");
+
 _Static_assert(sizeof(fixed_int8m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_int16m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_int32m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, "");
 
 _Static_assert(sizeof(fixed_uint8m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_uint16m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_uint32m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, "");
 
 _Static_assert(sizeof(fixed_float32m1_t) == VECTOR_SIZE, "");
 _Static_assert(sizeof(fixed_float64m1_t) == VECTOR_SIZE, "");
 
+_Static_assert(sizeof(fixed_int8m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_int16m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_int32m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_int64m2_t) == VECTOR_SIZE * 2, "");
+
+_Static_assert(sizeof(fixed_uint8m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_uint16m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_uint32m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_int64m2_t) == VECTOR_SIZE * 2, "");
+
+_Static_assert(sizeof(fixed_float32m2_t) == VECTOR_SIZE * 2, "");
+_Static_assert(sizeof(fixed_float64m2_t) == VECTOR_SIZE * 2, "");
+
+_Static_assert(sizeof(fixed_int8m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_int16m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_int32m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_int64m4_t) == VECTOR_SIZE * 4, "");
+
+_Static_assert(sizeof(fixed_uint8m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_uint16m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_uint32m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_int64m4_t) == VECTOR_SIZE * 4, "");
+
+_Static_assert(sizeof(fixed_float32m4_t) == VECTOR_SIZE * 4, "");
+_Static_assert(sizeof(fixed_float64m4_t) == VECTOR_SIZE * 4, "");
+
+_Static_assert(sizeof(fixed_int8m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_int16m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_int32m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_int64m8_t) == VECTOR_SIZE * 8, "");
+
+_Static_assert(sizeof(fixed_uint8m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_uint16m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_uint32m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_int64m8_t) == VECTOR_SIZE * 8, "");
+
+_Static_assert(sizeof(fixed_float32m8_t) == VECTOR_SIZE * 8, "");
+_Static_assert(sizeof(fixed_float64m8_t) == VECTOR_SIZE * 8, "");
+
 // --------------------------------------------------------------------------//
 // Alignof
 
 #define VECTOR_ALIGN 8
 
+_Static_assert(__alignof__(fixed_int8mf8_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8mf8_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_int8mf4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16mf4_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8mf4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16mf4_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_int8mf2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16mf2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int32mf2_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8mf2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16mf2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint32mf2_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_float32mf2_t) == VECTOR_ALIGN, "");
+
 _Static_assert(__alignof__(fixed_int8m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_int16m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_int32m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_int64m1_t) == VECTOR_ALIGN, "");
 
 _Static_assert(__alignof__(fixed_uint8m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_uint16m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_uint32m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_uint64m1_t) == VECTOR_ALIGN, "");
 
 _Static_assert(__alignof__(fixed_float32m1_t) == VECTOR_ALIGN, "");
 _Static_assert(__alignof__(fixed_float64m1_t) == VECTOR_ALIGN, "");
 
+_Static_assert(__alignof__(fixed_int8m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int32m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int64m2_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint32m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint64m2_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_float32m2_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_float64m2_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_int8m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int32m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int64m4_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint32m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint64m4_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_float32m4_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_float64m4_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_int8m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int32m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int64m8_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint32m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint64m8_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_float32m8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_float64m8_t) == VECTOR_ALIGN, "");
+
 // --------------------------------------------------------------------------//
 // Structs
 
 struct struct_int64 { fixed_int64m1_t x, y[5]; };
 struct struct_float64 { fixed_float64m1_t x, y[5]; };
 
+struct struct_int64m2 { fixed_int64m2_t x, y[5]; };
+struct struct_float64m2 { fixed_float64m2_t x, y[5]; };
+
+struct struct_int64m4 { fixed_int64m4_t x, y[5]; };
+struct struct_float64m4 { fixed_float64m4_t x, y[5]; };
+
+struct struct_int64m8 { fixed_int64m8_t x, y[5]; };
+struct struct_float64m8 { fixed_float64m8_t x, y[5]; };
+
 // --------------------------------------------------------------------------//
 // Unions
 union union_int64 { fixed_int64m1_t x, y[5]; };
 union union_float64 { fixed_float64m1_t x, y[5]; };
 
+union union_int64m2 { fixed_int64m2_t x, y[5]; };
+union union_float64m2 { fixed_float64m2_t x, y[5]; };
+
+union union_int64m4 { fixed_int64m4_t x, y[5]; };
+union union_float64m4 { fixed_float64m4_t x, y[5]; };
+
+union union_int64m8 { fixed_int64m8_t x, y[5]; };
+union union_float64m8 { fixed_float64m8_t x, y[5]; };
+
 // --------------------------------------------------------------------------//
 // Implicit casts
 
 #define TEST_CAST_COMMON(TYPE)                                              \
   v##TYPE##_t to_v##TYPE##_t_from_fixed(fixed_##TYPE##_t x) { return x; } \
   fixed_##TYPE##_t from_##TYPE##_t_to_fixed(v##TYPE##_t x) { return x; }
 
 #define TEST_CAST_GNU(PREFIX, TYPE)                                                          \
   gnu_##TYPE##_t to_gnu_##TYPE##_t_from_##PREFIX##TYPE##_t(PREFIX##TYPE##_t x) { return x; } \
   PREFIX##TYPE##_t from_gnu_##TYPE##_t_to_##PREFIX##TYPE##_t(gnu_##TYPE##_t x) { return x; }
 
 #define TEST_CAST_VECTOR(TYPE) \
   TEST_CAST_COMMON(TYPE)       \
   TEST_CAST_GNU(v, TYPE)      \
   TEST_CAST_GNU(fixed_, TYPE)
 
+TEST_CAST_VECTOR(int8mf8)
+TEST_CAST_VECTOR(uint8mf8)
+
+TEST_CAST_VECTOR(int8mf4)
+TEST_CAST_VECTOR(int16mf4)
+TEST_CAST_VECTOR(uint8mf4)
+TEST_CAST_VECTOR(uint16mf4)
+
+TEST_CAST_VECTOR(int8mf2)
+TEST_CAST_VECTOR(int16mf2)
+TEST_CAST_VECTOR(int32mf2)
+TEST_CAST_VECTOR(uint8mf2)
+TEST_CAST_VECTOR(uint16mf2)
+TEST_CAST_VECTOR(uint32mf2)
+TEST_CAST_VECTOR(float32mf2)
+
 TEST_CAST_VECTOR(int8m1)
 TEST_CAST_VECTOR(int16m1)
 TEST_CAST_VECTOR(int32m1)
 TEST_CAST_VECTOR(int64m1)
 TEST_CAST_VECTOR(uint8m1)
 TEST_CAST_VECTOR(uint16m1)
 TEST_CAST_VECTOR(uint32m1)
 TEST_CAST_VECTOR(uint64m1)
 TEST_CAST_VECTOR(float32m1)
 TEST_CAST_VECTOR(float64m1)
 
-// Test that casts only work for LMUL=1 types and don't crash.
-vint32m2_t to_vint32m2_t_from_gnut(gnu_int32m2_t x) { return x; } // expected-error-re {{returning 'gnu_int32m2_t' (vector of {{[0-9]+}} 'int32_t' values) from a function with incompatible result type 'vint32m2_t' (aka '__rvv_int32m2_t')}}
-
-gnu_int32m2_t to_gnut_from_svint32_t(vint32m2_t x) { return x; } // expected-error-re {{returning 'vint32m2_t' (aka '__rvv_int32m2_t') from a function with incompatible result type 'gnu_int32m2_t' (vector of {{[0-9]+}} 'int32_t' values)}}
+TEST_CAST_VECTOR(int8m2)
+TEST_CAST_VECTOR(int16m2)
+TEST_CAST_VECTOR(int32m2)
+TEST_CAST_VECTOR(int64m2)
+TEST_CAST_VECTOR(uint8m2)
+TEST_CAST_VECTOR(uint16m2)
+TEST_CAST_VECTOR(uint32m2)
+TEST_CAST_VECTOR(uint64m2)
+TEST_CAST_VECTOR(float32m2)
+TEST_CAST_VECTOR(float64m2)
+
+TEST_CAST_VECTOR(int8m4)
+TEST_CAST_VECTOR(int16m4)
+TEST_CAST_VECTOR(int32m4)
+TEST_CAST_VECTOR(int64m4)
+TEST_CAST_VECTOR(uint8m4)
+TEST_CAST_VECTOR(uint16m4)
+TEST_CAST_VECTOR(uint32m4)
+TEST_CAST_VECTOR(uint64m4)
+TEST_CAST_VECTOR(float32m4)
+TEST_CAST_VECTOR(float64m4)
+
+TEST_CAST_VECTOR(int8m8)
+TEST_CAST_VECTOR(int16m8)
+TEST_CAST_VECTOR(int32m8)
+TEST_CAST_VECTOR(int64m8)
+TEST_CAST_VECTOR(uint8m8)
+TEST_CAST_VECTOR(uint16m8)
+TEST_CAST_VECTOR(uint32m8)
+TEST_CAST_VECTOR(uint64m8)
+TEST_CAST_VECTOR(float32m8)
+TEST_CAST_VECTOR(float64m8)
 
 // --------------------------------------------------------------------------//
 // Test the scalable and fixed-length types can be used interchangeably
 
 vint32m1_t __attribute__((overloadable)) vfunc(vint32m1_t op1, vint32m1_t op2);
 vfloat64m1_t __attribute__((overloadable)) vfunc(vfloat64m1_t op1, vfloat64m1_t op2);
 
+vint32m2_t __attribute__((overloadable)) vfunc(vint32m2_t op1, vint32m2_t op2);
+vfloat64m2_t __attribute__((overloadable)) vfunc(vfloat64m2_t op1, vfloat64m2_t op2);
+
+vint32m4_t __attribute__((overloadable)) vfunc(vint32m4_t op1, vint32m4_t op2);
+vfloat64m4_t __attribute__((overloadable)) vfunc(vfloat64m4_t op1, vfloat64m4_t op2);
+
+vint32m8_t __attribute__((overloadable)) vfunc(vint32m8_t op1, vint32m8_t op2);
+vfloat64m8_t __attribute__((overloadable)) vfunc(vfloat64m8_t op1, vfloat64m8_t op2);
+
 #define TEST_CALL(TYPE)                                              \
   fixed_##TYPE##_t                                                   \
       call_##TYPE##_ff(fixed_##TYPE##_t op1, fixed_##TYPE##_t op2) { \
     return vfunc(op1, op2);                                         \
   }                                                                  \
   fixed_##TYPE##_t                                                   \
       call_##TYPE##_fs(fixed_##TYPE##_t op1, v##TYPE##_t op2) {     \
     return vfunc(op1, op2);                                         \
   }                                                                  \
   fixed_##TYPE##_t                                                   \
       call_##TYPE##_sf(v##TYPE##_t op1, fixed_##TYPE##_t op2) {     \
     return vfunc(op1, op2);                                         \
   }
 
 TEST_CALL(int32m1)
 TEST_CALL(float64m1)
 
+TEST_CALL(int32m2)
+TEST_CALL(float64m2)
+
+TEST_CALL(int32m4)
+TEST_CALL(float64m4)
+
+TEST_CALL(int32m8)
+TEST_CALL(float64m8)
+
 // --------------------------------------------------------------------------//
 // Vector initialization
 
 #if __riscv_v_fixed_vlen == 256
 
 typedef vint32m1_t int32x8 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 typedef vfloat64m1_t float64x4 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
 
+typedef vint32m2_t int32x16 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+typedef vfloat64m2_t float64x8 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2)));
+
+typedef vint32m4_t int32x32 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+typedef vfloat64m4_t float64x16 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4)));
+
+typedef vint32m8_t int32x64 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+typedef vfloat64m8_t float64x32 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8)));
+
 int32x8 foo = {1, 2, 3, 4, 5, 6, 7, 8};
 int32x8 foo2 = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // expected-warning{{excess elements in vector initializer}}
 
 float64x4 bar = {1.0, 2.0, 3.0, 4.0};
 float64x4 bar2 = {1.0, 2.0, 3.0, 4.0, 5.0}; // expected-warning{{excess elements in vector initializer}}
 
+int32x16 foom2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+int32x16 foo2m2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}; // expected-warning{{excess elements in vector initializer}}
+
+float64x8 barm2 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
+float64x8 bar2m2 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; // expected-warning{{excess elements in vector initializer}}
+
+int32x32 foom4 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                  17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                  32};
+int32x32 foo2m4 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                   17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                   32, 33}; // expected-warning{{excess elements in vector initializer}}
+
+float64x16 barm4 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
+                    12.0, 13.0, 14.0, 15.0, 16.0};
+float64x16 bar2m4 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
+                     12.0, 13.0, 14.0, 15.0, 16.0, 17.0}; // expected-warning{{excess elements in vector initializer}}
+
+int32x64 foom8 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+                  19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
+                  34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+                  49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+                  64};
+int32x64 foo2m8 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+                   18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+                   33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+                   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+                   63, 64, 65}; // expected-warning{{excess elements in vector initializer}}
+
+float64x32 barm8 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
+                    12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0,
+                    22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0,
+                    32.0};
+float64x32 bar2m8 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,
+                     12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0,
+                     22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0,
+                     32.0, 33.0}; // expected-warning{{excess elements in vector initializer}}
 #endif
 
 // --------------------------------------------------------------------------//
 // Vector ops
 
 #define TEST_BINARY(TYPE, NAME, OP)                  \
   TYPE NAME##_##TYPE(TYPE op1, TYPE op2) {           \
     return op1 OP op2;                               \
#define TEST_INT_OPS(TYPE)   \
   TEST_BINARY(TYPE, mod, %)  \
   TEST_BINARY(TYPE, and, &)  \
   TEST_BINARY(TYPE, or, |)   \
   TEST_BINARY(TYPE, xor, ^)  \
   TEST_BINARY(TYPE, shl, <<) \
   TEST_BINARY(TYPE, shr, <<) \
   TEST_UNARY(TYPE, not, ~)
 
+TEST_INT_OPS(fixed_int8mf8_t)
+TEST_INT_OPS(fixed_uint8mf8_t)
+
+TEST_INT_OPS(fixed_int8mf4_t)
+TEST_INT_OPS(fixed_int16mf4_t)
+TEST_INT_OPS(fixed_uint8mf4_t)
+TEST_INT_OPS(fixed_uint16mf4_t)
+
+TEST_INT_OPS(fixed_int8mf2_t)
+TEST_INT_OPS(fixed_int16mf2_t)
+TEST_INT_OPS(fixed_int32mf2_t)
+TEST_INT_OPS(fixed_uint8mf2_t)
+TEST_INT_OPS(fixed_uint16mf2_t)
+TEST_INT_OPS(fixed_uint32mf2_t)
+
+TEST_OPS(fixed_float32mf2_t)
+
 TEST_INT_OPS(fixed_int8m1_t)
 TEST_INT_OPS(fixed_int16m1_t)
 TEST_INT_OPS(fixed_int32m1_t)
 TEST_INT_OPS(fixed_int64m1_t)
 TEST_INT_OPS(fixed_uint8m1_t)
 TEST_INT_OPS(fixed_uint16m1_t)
 TEST_INT_OPS(fixed_uint32m1_t)
 TEST_INT_OPS(fixed_uint64m1_t)
 
 TEST_OPS(fixed_float32m1_t)
 TEST_OPS(fixed_float64m1_t)
+
+TEST_INT_OPS(fixed_int8m2_t)
+TEST_INT_OPS(fixed_int16m2_t)
+TEST_INT_OPS(fixed_int32m2_t)
+TEST_INT_OPS(fixed_int64m2_t)
+TEST_INT_OPS(fixed_uint8m2_t)
+TEST_INT_OPS(fixed_uint16m2_t)
+TEST_INT_OPS(fixed_uint32m2_t)
+TEST_INT_OPS(fixed_uint64m2_t)
+
+TEST_OPS(fixed_float32m2_t)
+TEST_OPS(fixed_float64m2_t)
+
+TEST_INT_OPS(fixed_int8m4_t)
+TEST_INT_OPS(fixed_int16m4_t)
+TEST_INT_OPS(fixed_int32m4_t)
+TEST_INT_OPS(fixed_int64m4_t)
+TEST_INT_OPS(fixed_uint8m4_t)
+TEST_INT_OPS(fixed_uint16m4_t)
+TEST_INT_OPS(fixed_uint32m4_t)
+TEST_INT_OPS(fixed_uint64m4_t)
+
+TEST_OPS(fixed_float32m4_t)
+TEST_OPS(fixed_float64m4_t)
+
+TEST_INT_OPS(fixed_int8m8_t)
+TEST_INT_OPS(fixed_int16m8_t)
+TEST_INT_OPS(fixed_int32m8_t)
+TEST_INT_OPS(fixed_int64m8_t)
+TEST_INT_OPS(fixed_uint8m8_t)
+TEST_INT_OPS(fixed_uint16m8_t)
+TEST_INT_OPS(fixed_uint32m8_t)
+TEST_INT_OPS(fixed_uint64m8_t)
+
+TEST_OPS(fixed_float32m8_t)
+TEST_OPS(fixed_float64m8_t)