diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -2340,11 +2340,14 @@ 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. }]; } diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3078,8 +3078,8 @@ "%0 is only supported when '-mrvv-vector-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< diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -9579,11 +9579,8 @@ auto IsValidCast = [this](QualType FirstType, QualType SecondType) { if (const auto *BT = FirstType->getAs()) { if (const auto *VT = SecondType->getAs()) { - 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(), diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -2448,10 +2448,9 @@ bool Type::isRVVVLSBuiltinType() const { if (const BuiltinType *BT = getAs()) { 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; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -40,7 +40,6 @@ #include "llvm/ADT/SmallString.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/Support/ErrorHandling.h" -#include "llvm/TargetParser/RISCVTargetParser.h" #include #include @@ -8345,9 +8344,10 @@ 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; } diff --git a/clang/test/CodeGen/attr-riscv-rvv-vector-bits-codegen.c b/clang/test/CodeGen/attr-riscv-rvv-vector-bits-codegen.c --- a/clang/test/CodeGen/attr-riscv-rvv-vector-bits-codegen.c +++ b/clang/test/CodeGen/attr-riscv-rvv-vector-bits-codegen.c @@ -16,9 +16,22 @@ 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: @@ -75,3 +88,59 @@ 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 @llvm.vector.insert.nxv2i32.v16i32( undef, <16 x i32> [[TMP2]], i64 0) +// CHECK-NEXT: ret [[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 @llvm.vector.insert.nxv2i32.v16i32( undef, <16 x i32> [[TMP2]], i64 0) +// CHECK-NEXT: ret [[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 , align 4 +// CHECK-NEXT: store [[VEC:%.*]], ptr [[VEC_ADDR]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr @global_vec_m2, align 8 +// CHECK-NEXT: [[CASTSCALABLESVE:%.*]] = call @llvm.vector.insert.nxv4i32.v16i32( undef, <16 x i32> [[TMP0]], i64 0) +// CHECK-NEXT: [[TMP1:%.*]] = load , ptr [[VEC_ADDR]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = call @llvm.riscv.vadd.nxv4i32.nxv4i32.i64( poison, [[CASTSCALABLESVE]], [[TMP1]], i64 16) +// CHECK-NEXT: [[CASTFIXEDSVE:%.*]] = call <16 x i32> @llvm.vector.extract.v16i32.nxv4i32( [[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 @llvm.vector.insert.nxv2i32.v16i32( undef, <16 x i32> [[TMP3]], i64 0) +// CHECK-NEXT: ret [[CASTSCALABLESVE1]] +// +fixed_int32m2_t test_cast_m2(vint32m2_t vec) { + return __riscv_vadd(global_vec_m2, vec, __riscv_v_fixed_vlen/16); +} diff --git a/clang/test/CodeGen/attr-riscv-rvv-vector-bits-types.c b/clang/test/CodeGen/attr-riscv-rvv-vector-bits-types.c --- a/clang/test/CodeGen/attr-riscv-rvv-vector-bits-types.c +++ b/clang/test/CodeGen/attr-riscv-rvv-vector-bits-types.c @@ -19,6 +19,39 @@ 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))); @@ -33,6 +66,45 @@ 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 //===----------------------------------------------------------------------===// @@ -57,6 +129,39 @@ 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) @@ -68,6 +173,39 @@ 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 //===----------------------------------------------------------------------===// @@ -84,6 +222,45 @@ 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 //===----------------------------------------------------------------------===// @@ -100,6 +277,45 @@ 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 //===----------------------------------------------------------------------===// @@ -116,6 +332,39 @@ 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]; @@ -127,6 +376,39 @@ 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]; } //===----------------------------------------------------------------------===// @@ -142,6 +424,36 @@ // 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> } @@ -153,6 +465,36 @@ // 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> } @@ -164,6 +506,35 @@ // 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> } @@ -175,6 +546,35 @@ // 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> } @@ -186,6 +586,35 @@ // 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> } @@ -197,6 +626,36 @@ // 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> } @@ -208,6 +667,36 @@ // 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> } @@ -219,6 +708,36 @@ // 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> } @@ -230,6 +749,36 @@ // 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> } @@ -241,6 +790,36 @@ // 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 @@ -255,6 +834,36 @@ // 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 @@ -266,6 +875,36 @@ // 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 @@ -277,6 +916,36 @@ // 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 @@ -288,6 +957,36 @@ // 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 @@ -299,6 +998,36 @@ // 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 @@ -313,6 +1042,36 @@ // 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 @@ -324,6 +1083,36 @@ // 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 @@ -335,7 +1124,36 @@ // 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 @@ -346,6 +1164,36 @@ // 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 @@ -357,6 +1205,36 @@ // 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 @@ -371,6 +1249,36 @@ // 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 @@ -382,6 +1290,36 @@ // 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 @@ -393,6 +1331,36 @@ // 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 @@ -404,6 +1372,36 @@ // 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 @@ -415,6 +1413,36 @@ // 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 @@ -429,6 +1457,36 @@ // 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 @@ -440,6 +1498,36 @@ // 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 @@ -451,6 +1539,36 @@ // 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 @@ -462,6 +1580,36 @@ // 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 @@ -473,3 +1621,33 @@ // 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 diff --git a/clang/test/Driver/riscv-rvv-vector-bits.c b/clang/test/Driver/riscv-rvv-vector-bits.c --- a/clang/test/Driver/riscv-rvv-vector-bits.c +++ b/clang/test/Driver/riscv-rvv-vector-bits.c @@ -63,4 +63,4 @@ 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' diff --git a/clang/test/Sema/attr-riscv-rvv-vector-bits.c b/clang/test/Sema/attr-riscv-rvv-vector-bits.c --- a/clang/test/Sema/attr-riscv-rvv-vector-bits.c +++ b/clang/test/Sema/attr-riscv-rvv-vector-bits.c @@ -75,6 +75,26 @@ 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))); @@ -88,7 +108,66 @@ 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))); @@ -102,7 +181,44 @@ 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}} @@ -114,12 +230,6 @@ // bool types and LMUL != 1 are not supported. typedef vbool1_t fixed_vbool1_t_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vbool1_t'}} -typedef vint8mf8_t fixed_int8mf8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 8))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8mf8_t'}} -typedef vint8mf4_t fixed_int8mf4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 4))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8mf4_t'}} -typedef vint8mf2_t fixed_int8mf2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen / 2))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8mf2_t'}} -typedef vint8m2_t fixed_int8m2_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 2))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8m2_t'}} -typedef vint8m4_t fixed_int8m4_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 4))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8m4_t'}} -typedef vint8m8_t fixed_int8m8_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen * 8))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'vint8m8_t'}} // Attribute must be attached to a single RVV vector or predicate type. typedef void *badtype1 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'void *'}} @@ -216,6 +326,26 @@ #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, ""); @@ -229,11 +359,70 @@ _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, ""); @@ -247,17 +436,74 @@ _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 @@ -274,6 +520,22 @@ 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) @@ -285,10 +547,38 @@ 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 @@ -296,6 +586,15 @@ 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) { \ @@ -313,6 +612,15 @@ 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 @@ -321,12 +629,58 @@ 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 // --------------------------------------------------------------------------// @@ -375,6 +729,23 @@ 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) @@ -386,3 +757,39 @@ 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)