This is an archive of the discontinued LLVM Phabricator instance.

Differential D150926

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

Authored by craig.topper on May 18 2023, 6:21 PM.

Details

Reviewers
aaron.ballman
kito-cheng
asb
frasercrmck
rogfer01
reames
Commits
rG72d23a2ec1b9: [RISCV] Support LMUL!=1 for __attribute__((riscv_rvv_vector_bits(N)))
Summary

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

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

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

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

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

Diff Detail

Event Timeline

craig.topper created this revision.May 18 2023, 6:21 PM
Herald added a reviewer: aaron.ballman. · View Herald TranscriptMay 18 2023, 6:21 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: jobnoorman, luke, VincentWu and 27 others. · View Herald Transcript
craig.topper requested review of this revision.May 18 2023, 6:21 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 18 2023, 6:21 PM
Herald added subscribers: cfe-commits, • pcwang-thead, eopXD. · View Herald Transcript
craig.topper added reviewers: kito-cheng, asb, frasercrmck, rogfer01, reames.May 18 2023, 6:22 PM
Harbormaster completed remote builds in B233065: Diff 523630.May 19 2023, 2:22 AM
asb added inline comments.May 19 2023, 7:46 AM
clang/include/clang/Basic/AttrDocs.td
2347–2350

LMULo -> LMUL

craig.topper updated this revision to Diff 523825.May 19 2023, 9:35 AM

Fix typo

Harbormaster completed remote builds in B233215: Diff 523825.May 19 2023, 12:14 PM
craig.topper added a comment.May 25 2023, 10:35 AM

Ping

craig.topper added a comment.May 31 2023, 12:38 PM

Ping

craig.topper added a comment.Jun 7 2023, 8:43 AM

Ping * 3

aaron.ballman added inline comments.Jun 7 2023, 10:58 AM
clang/include/clang/Basic/AttrDocs.td
2350

Do you have test coverage that demonstrates this?

clang/lib/AST/Type.cpp
2450–2451

FIXME is now stale and can be removed?

clang/lib/Sema/SemaType.cpp
8347–8348

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

craig.topper added inline comments.Jun 7 2023, 1:00 PM
clang/lib/Sema/SemaType.cpp
8347–8348

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

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

craig.topper updated this revision to Diff 529475.Jun 7 2023, 5:16 PM

Remove stale FIXME

Harbormaster completed remote builds in B237399: Diff 529475.Jun 7 2023, 7:17 PM
aaron.ballman accepted this revision.Jun 8 2023, 5:32 AM

LGTM

clang/lib/Sema/SemaType.cpp
8347–8348

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

Fantastic, thank you!

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

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

This revision is now accepted and ready to land.Jun 8 2023, 5:32 AM
This revision was landed with ongoing or failed builds.Jun 8 2023, 9:14 AM
Closed by commit rG72d23a2ec1b9: [RISCV] Support LMUL!=1 for __attribute__((riscv_rvv_vector_bits(N))) (authored by craig.topper). · Explain Why
This revision was automatically updated to reflect the committed changes.
craig.topper added a commit: rG72d23a2ec1b9: [RISCV] Support LMUL!=1 for __attribute__((riscv_rvv_vector_bits(N))).

Revision Contents

PathSize
clang/
include/
clang/
Basic/
7 lines
4 lines
lib/
AST/
7 lines
3 lines
Sema/
6 lines
test/
CodeGen/
69 lines
1180 lines
Driver/
2 lines
Sema/
429 lines

Diff 529628

clang/include/clang/Basic/AttrDocs.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,334 Lines • ▼ Show 20 Lines
Creates a type ``fixed_vint8m1_t_t`` that is a fixed-length variant of Creates a type ``fixed_vint8m1_t_t`` that is a fixed-length variant of
``vint8m1_t`` that contains exactly 512 bits. Unlike ``vint8m1_t``, this type ``vint8m1_t`` that contains exactly 512 bits. Unlike ``vint8m1_t``, this type
can be used in globals, structs, unions, and arrays, all of which are can be used in globals, structs, unions, and arrays, all of which are
unsupported for sizeless types. unsupported for sizeless types.
The attribute can be attached to a single RVV vector (such as ``vint8m1_t``). The attribute can be attached to a single RVV vector (such as ``vint8m1_t``).
The attribute will be rejected unless 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 is enabled under the ``-mrvv-vector-bits`` flag. ``__riscv_v_fixed_vlen`` can
only be a power of 2 between 64 and 65536. 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.
asbUnsubmitted
Not Done
ReplyInline Actions

LMULo -> LMUL

asb: LMULo -> LMUL
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

Do you have test coverage that demonstrates this?

aaron.ballman: Do you have test coverage that demonstrates this?
}]; }];
} }
def AVRInterruptDocs : Documentation { def AVRInterruptDocs : Documentation {
let Category = DocCatFunction; let Category = DocCatFunction;
let Heading = "interrupt (AVR)"; let Heading = "interrupt (AVR)";
let Content = [{ let Content = [{
Clang supports the GNU style ``__attribute__((interrupt))`` attribute on Clang supports the GNU style ``__attribute__((interrupt))`` attribute on
▲ Show 20 Lines • Show All 4,697 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,072 Lines • ▼ Show 20 Linesdef err_attribute_arm_feature_sve_bits_unsupported : Error<
"%0 is only supported when '-msve-vector-bits=<bits>' is specified with a " "%0 is only supported when '-msve-vector-bits=<bits>' is specified with a "
"value of 128, 256, 512, 1024 or 2048.">; "value of 128, 256, 512, 1024 or 2048.">;
def err_sve_vector_in_non_sve_target : Error< def err_sve_vector_in_non_sve_target : Error<
"SVE vector type %0 cannot be used in a target without sve">; "SVE vector type %0 cannot be used in a target without sve">;
def err_attribute_riscv_rvv_bits_unsupported : Error< def err_attribute_riscv_rvv_bits_unsupported : Error<
"%0 is only supported when '-mrvv-vector-bits=<bits>' is specified with a " "%0 is only supported when '-mrvv-vector-bits=<bits>' is specified with a "
"value of \"zvl\" or a power 2 in the range [64,65536]">; "value of \"zvl\" or a power 2 in the range [64,65536]">;
def err_attribute_bad_rvv_vector_size : Error< def err_attribute_bad_rvv_vector_size : Error<
"invalid RVV vector size '%0', must match value set by " "invalid RVV vector size '%0', expected size is '%1' based on LMUL of type "
"'-mrvv-vector-bits' ('%1')">; "and '-mrvv-vector-bits'">;
def err_attribute_invalid_rvv_type : Error< def err_attribute_invalid_rvv_type : Error<
"%0 attribute applied to non-RVV type %1">; "%0 attribute applied to non-RVV type %1">;
def err_attribute_requires_positive_integer : Error< def err_attribute_requires_positive_integer : Error<
"%0 attribute requires a %select{positive|non-negative}1 " "%0 attribute requires a %select{positive|non-negative}1 "
"integral compile time constant expression">; "integral compile time constant expression">;
def err_attribute_requires_opencl_version : Error< def err_attribute_requires_opencl_version : Error<
"attribute %0 is supported in the OpenCL version %1%select{| onwards}2">; "attribute %0 is supported in the OpenCL version %1%select{| onwards}2">;
def err_invalid_branch_protection_spec : Error< def err_invalid_branch_protection_spec : Error<
▲ Show 20 Lines • Show All 8,777 Lines • Show Last 20 Lines

clang/lib/AST/ASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,573 Lines • ▼ Show 20 Linesbool ASTContext::areCompatibleRVVTypes(QualType FirstType,
assert( assert(
((FirstType->isRVVSizelessBuiltinType() && SecondType->isVectorType()) || ((FirstType->isRVVSizelessBuiltinType() && SecondType->isVectorType()) ||
(FirstType->isVectorType() && SecondType->isRVVSizelessBuiltinType())) && (FirstType->isVectorType() && SecondType->isRVVSizelessBuiltinType())) &&
"Expected RVV builtin type and vector type!"); "Expected RVV builtin type and vector type!");
auto IsValidCast = [this](QualType FirstType, QualType SecondType) { auto IsValidCast = [this](QualType FirstType, QualType SecondType) {
if (const auto *BT = FirstType->getAs<BuiltinType>()) { if (const auto *BT = FirstType->getAs<BuiltinType>()) {
if (const auto *VT = SecondType->getAs<VectorType>()) { if (const auto *VT = SecondType->getAs<VectorType>()) {
if (VT->getVectorKind() == VectorType::RVVFixedLengthDataVector) if (VT->getVectorKind() == VectorType::RVVFixedLengthDataVector ||
return FirstType->isRVVVLSBuiltinType() && VT->getVectorKind() == VectorType::GenericVector)
VT->getElementType().getCanonicalType() ==
FirstType->getRVVEltType(*this);
if (VT->getVectorKind() == VectorType::GenericVector)
return FirstType->isRVVVLSBuiltinType() && return FirstType->isRVVVLSBuiltinType() &&
getTypeSize(SecondType) == getRVVTypeSize(*this, BT) && getTypeSize(SecondType) == getRVVTypeSize(*this, BT) &&
hasSameType(VT->getElementType(), hasSameType(VT->getElementType(),
getBuiltinVectorTypeInfo(BT).ElementType); getBuiltinVectorTypeInfo(BT).ElementType);
} }
} }
return false; return false;
}; };
▲ Show 20 Lines • Show All 4,020 Lines • Show Last 20 Lines

clang/lib/AST/Type.cpp

Show First 20 Lines • Show All 2,441 Lines • ▼ Show 20 Lines if (BTy->getKind() == BuiltinType::SveBool)
// scalable and fixed-length vectors. // scalable and fixed-length vectors.
return Ctx.UnsignedCharTy; return Ctx.UnsignedCharTy;
else else
return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType; return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
} }
bool Type::isRVVVLSBuiltinType() const { bool Type::isRVVVLSBuiltinType() const {
if (const BuiltinType *BT = getAs<BuiltinType>()) { if (const BuiltinType *BT = getAs<BuiltinType>()) {
switch (BT->getKind()) { switch (BT->getKind()) {
// FIXME: Support more than LMUL 1.
#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, IsFP) \ #define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, IsFP) \
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

FIXME is now stale and can be removed?

aaron.ballman: FIXME is now stale and can be removed?
case BuiltinType::Id: \ case BuiltinType::Id: \
return NF == 1 && (NumEls * ElBits) == llvm::RISCV::RVVBitsPerBlock; return NF == 1;
#include "clang/Basic/RISCVVTypes.def" #include "clang/Basic/RISCVVTypes.def"
default: default:
return false; return false;
} }
} }
return false; return false;
} }
▲ Show 20 Lines • Show All 2,261 Lines • Show Last 20 Lines

clang/lib/Sema/SemaType.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show All 34 Lines
#include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaInternal.h"
#include "clang/Sema/Template.h" #include "clang/Sema/Template.h"
#include "clang/Sema/TemplateInstCallback.h" #include "clang/Sema/TemplateInstCallback.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/TargetParser/RISCVTargetParser.h"
#include <bitset> #include <bitset>
#include <optional> #include <optional>
using namespace clang; using namespace clang;
enum TypeDiagSelector { enum TypeDiagSelector {
TDS_Function, TDS_Function,
TDS_Pointer, TDS_Pointer,
▲ Show 20 Lines • Show All 8,288 Lines • ▼ Show 20 Linesstatic void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType,
unsigned VecSize = static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue()); unsigned VecSize = static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
ASTContext::BuiltinVectorTypeInfo Info = ASTContext::BuiltinVectorTypeInfo Info =
S.Context.getBuiltinVectorTypeInfo(CurType->castAs<BuiltinType>()); S.Context.getBuiltinVectorTypeInfo(CurType->castAs<BuiltinType>());
unsigned EltSize = S.Context.getTypeSize(Info.ElementType); unsigned EltSize = S.Context.getTypeSize(Info.ElementType);
unsigned MinElts = Info.EC.getKnownMinValue(); unsigned MinElts = Info.EC.getKnownMinValue();
// The attribute vector size must match -mrvv-vector-bits. // The attribute vector size must match -mrvv-vector-bits.
if (VecSize != VScale->first * MinElts * EltSize) { unsigned ExpectedSize = VScale->first * MinElts * EltSize;
if (VecSize != ExpectedSize) {
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

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

aaron.ballman: Random thought I didn't think to ask earlier: is it possible for this multiplication to…
craig.topperAuthorUnsubmitted
Done
ReplyInline Actions

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

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

craig.topper: The largest value for -mrvv-vector-bits is 65536 which makes VScale->first 65536/64 == 1024.
aaron.ballmanUnsubmitted
Not Done
ReplyInline Actions

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

Fantastic, thank you!

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

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

aaron.ballman: > The largest value for -mrvv-vector-bits is 65536 which makes VScale->first 65536/64 == 1024.
S.Diag(Attr.getLoc(), diag::err_attribute_bad_rvv_vector_size) S.Diag(Attr.getLoc(), diag::err_attribute_bad_rvv_vector_size)
<< VecSize << VScale->first * llvm::RISCV::RVVBitsPerBlock; << VecSize << ExpectedSize;
Attr.setInvalid(); Attr.setInvalid();
return; return;
} }
VectorType::VectorKind VecKind = VectorType::RVVFixedLengthDataVector; VectorType::VectorKind VecKind = VectorType::RVVFixedLengthDataVector;
VecSize /= EltSize; VecSize /= EltSize;
CurType = S.Context.getVectorType(Info.ElementType, VecSize, VecKind); CurType = S.Context.getVectorType(Info.ElementType, VecSize, VecKind);
} }
▲ Show 20 Lines • Show All 1,400 Lines • Show Last 20 Lines

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

Show All 10 Lines
typedef __rvv_uint16m1_t vuint16m1_t; typedef __rvv_uint16m1_t vuint16m1_t;
typedef __rvv_int32m1_t vint32m1_t; typedef __rvv_int32m1_t vint32m1_t;
typedef __rvv_uint32m1_t vuint32m1_t; typedef __rvv_uint32m1_t vuint32m1_t;
typedef __rvv_int64m1_t vint64m1_t; typedef __rvv_int64m1_t vint64m1_t;
typedef __rvv_uint64m1_t vuint64m1_t; typedef __rvv_uint64m1_t vuint64m1_t;
typedef __rvv_float32m1_t vfloat32m1_t; typedef __rvv_float32m1_t vfloat32m1_t;
typedef __rvv_float64m1_t vfloat64m1_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 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_int32m1_t global_vec;
fixed_int32m2_t global_vec_m2;
// CHECK-LABEL: @test_ptr_to_global( // CHECK-LABEL: @test_ptr_to_global(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca <8 x i32>, align 8 // CHECK-NEXT: [[RETVAL:%.*]] = alloca <8 x i32>, align 8
// CHECK-NEXT: [[GLOBAL_VEC_PTR:%.*]] = alloca ptr, align 8 // CHECK-NEXT: [[GLOBAL_VEC_PTR:%.*]] = alloca ptr, align 8
// CHECK-NEXT: store ptr @global_vec, ptr [[GLOBAL_VEC_PTR]], align 8 // CHECK-NEXT: store ptr @global_vec, ptr [[GLOBAL_VEC_PTR]], align 8
// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[GLOBAL_VEC_PTR]], align 8 // CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[GLOBAL_VEC_PTR]], align 8
// CHECK-NEXT: [[TMP1:%.*]] = load <8 x i32>, ptr [[TMP0]], align 8 // CHECK-NEXT: [[TMP1:%.*]] = load <8 x i32>, ptr [[TMP0]], align 8
Show All 40 Lines
// CHECK-NEXT: store <8 x i32> [[CASTFIXEDSVE]], ptr [[RETVAL]], align 8 // CHECK-NEXT: store <8 x i32> [[CASTFIXEDSVE]], ptr [[RETVAL]], align 8
// CHECK-NEXT: [[TMP3:%.*]] = load <8 x i32>, ptr [[RETVAL]], align 8 // CHECK-NEXT: [[TMP3:%.*]] = load <8 x i32>, ptr [[RETVAL]], align 8
// CHECK-NEXT: [[CASTSCALABLESVE1:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v8i32(<vscale x 2 x i32> undef, <8 x i32> [[TMP3]], i64 0) // CHECK-NEXT: [[CASTSCALABLESVE1:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v8i32(<vscale x 2 x i32> undef, <8 x i32> [[TMP3]], i64 0)
// CHECK-NEXT: ret <vscale x 2 x i32> [[CASTSCALABLESVE1]] // CHECK-NEXT: ret <vscale x 2 x i32> [[CASTSCALABLESVE1]]
// //
fixed_int32m1_t test_cast(vint32m1_t vec) { fixed_int32m1_t test_cast(vint32m1_t vec) {
return __riscv_vadd(global_vec, vec, __riscv_v_fixed_vlen/32); return __riscv_vadd(global_vec, vec, __riscv_v_fixed_vlen/32);
} }
// CHECK-LABEL: @test_ptr_to_global_m2(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca <16 x i32>, align 8
// CHECK-NEXT: [[GLOBAL_VEC_PTR:%.*]] = alloca ptr, align 8
// CHECK-NEXT: store ptr @global_vec_m2, ptr [[GLOBAL_VEC_PTR]], align 8
// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[GLOBAL_VEC_PTR]], align 8
// CHECK-NEXT: [[TMP1:%.*]] = load <16 x i32>, ptr [[TMP0]], align 8
// CHECK-NEXT: store <16 x i32> [[TMP1]], ptr [[RETVAL]], align 8
// CHECK-NEXT: [[TMP2:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
// CHECK-NEXT: [[CASTSCALABLESVE:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP2]], i64 0)
// CHECK-NEXT: ret <vscale x 2 x i32> [[CASTSCALABLESVE]]
//
fixed_int32m2_t test_ptr_to_global_m2() {
fixed_int32m2_t *global_vec_ptr;
global_vec_ptr = &global_vec_m2;
return *global_vec_ptr;
}
//
// Test casting pointer from fixed-length array to scalable vector.
// CHECK-LABEL: @array_arg_m2(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca <16 x i32>, align 8
// CHECK-NEXT: [[ARR_ADDR:%.*]] = alloca ptr, align 8
// CHECK-NEXT: store ptr [[ARR:%.*]], ptr [[ARR_ADDR]], align 8
// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[ARR_ADDR]], align 8
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds <16 x i32>, ptr [[TMP0]], i64 0
// CHECK-NEXT: [[TMP1:%.*]] = load <16 x i32>, ptr [[ARRAYIDX]], align 8
// CHECK-NEXT: store <16 x i32> [[TMP1]], ptr [[RETVAL]], align 8
// CHECK-NEXT: [[TMP2:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
// CHECK-NEXT: [[CASTSCALABLESVE:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP2]], i64 0)
// CHECK-NEXT: ret <vscale x 2 x i32> [[CASTSCALABLESVE]]
//
fixed_int32m2_t array_arg_m2(fixed_int32m2_t arr[]) {
return arr[0];
}
// CHECK-LABEL: @test_cast_m2(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca <16 x i32>, align 8
// CHECK-NEXT: [[VEC_ADDR:%.*]] = alloca <vscale x 4 x i32>, align 4
// CHECK-NEXT: store <vscale x 4 x i32> [[VEC:%.*]], ptr [[VEC_ADDR]], align 4
// CHECK-NEXT: [[TMP0:%.*]] = load <16 x i32>, ptr @global_vec_m2, align 8
// CHECK-NEXT: [[CASTSCALABLESVE:%.*]] = call <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v16i32(<vscale x 4 x i32> undef, <16 x i32> [[TMP0]], i64 0)
// CHECK-NEXT: [[TMP1:%.*]] = load <vscale x 4 x i32>, ptr [[VEC_ADDR]], align 4
// CHECK-NEXT: [[TMP2:%.*]] = call <vscale x 4 x i32> @llvm.riscv.vadd.nxv4i32.nxv4i32.i64(<vscale x 4 x i32> poison, <vscale x 4 x i32> [[CASTSCALABLESVE]], <vscale x 4 x i32> [[TMP1]], i64 16)
// CHECK-NEXT: [[CASTFIXEDSVE:%.*]] = call <16 x i32> @llvm.vector.extract.v16i32.nxv4i32(<vscale x 4 x i32> [[TMP2]], i64 0)
// CHECK-NEXT: store <16 x i32> [[CASTFIXEDSVE]], ptr [[RETVAL]], align 8
// CHECK-NEXT: [[TMP3:%.*]] = load <16 x i32>, ptr [[RETVAL]], align 8
// CHECK-NEXT: [[CASTSCALABLESVE1:%.*]] = call <vscale x 2 x i32> @llvm.vector.insert.nxv2i32.v16i32(<vscale x 2 x i32> undef, <16 x i32> [[TMP3]], i64 0)
// CHECK-NEXT: ret <vscale x 2 x i32> [[CASTSCALABLESVE1]]
//
fixed_int32m2_t test_cast_m2(vint32m2_t vec) {
return __riscv_vadd(global_vec_m2, vec, __riscv_v_fixed_vlen/16);
}

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

Show All 13 Lines
typedef __rvv_uint16m1_t vuint16m1_t; typedef __rvv_uint16m1_t vuint16m1_t;
typedef __rvv_int32m1_t vint32m1_t; typedef __rvv_int32m1_t vint32m1_t;
typedef __rvv_uint32m1_t vuint32m1_t; typedef __rvv_uint32m1_t vuint32m1_t;
typedef __rvv_int64m1_t vint64m1_t; typedef __rvv_int64m1_t vint64m1_t;
typedef __rvv_uint64m1_t vuint64m1_t; typedef __rvv_uint64m1_t vuint64m1_t;
typedef __rvv_float32m1_t vfloat32m1_t; typedef __rvv_float32m1_t vfloat32m1_t;
typedef __rvv_float64m1_t vfloat64m1_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 // Define valid fixed-width RVV types
typedef vint8m1_t fixed_int8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); 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 vint16m1_t fixed_int16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vfloat32m1_t fixed_float32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef 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 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 // Structs and unions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DEFINE_STRUCT(ty) \ #define DEFINE_STRUCT(ty) \
struct struct_##ty { \ struct struct_##ty { \
fixed_##ty##_t x; \ fixed_##ty##_t x; \
} struct_##ty; } struct_##ty;
#define DEFINE_UNION(ty) \ #define DEFINE_UNION(ty) \
union union_##ty { \ union union_##ty { \
fixed_##ty##_t x; \ fixed_##ty##_t x; \
} union_##ty; } union_##ty;
DEFINE_STRUCT(int8m1) DEFINE_STRUCT(int8m1)
DEFINE_STRUCT(int16m1) DEFINE_STRUCT(int16m1)
DEFINE_STRUCT(int32m1) DEFINE_STRUCT(int32m1)
DEFINE_STRUCT(int64m1) DEFINE_STRUCT(int64m1)
DEFINE_STRUCT(uint8m1) DEFINE_STRUCT(uint8m1)
DEFINE_STRUCT(uint16m1) DEFINE_STRUCT(uint16m1)
DEFINE_STRUCT(uint32m1) DEFINE_STRUCT(uint32m1)
DEFINE_STRUCT(uint64m1) DEFINE_STRUCT(uint64m1)
DEFINE_STRUCT(float32m1) DEFINE_STRUCT(float32m1)
DEFINE_STRUCT(float64m1) 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(int8m1)
DEFINE_UNION(int16m1) DEFINE_UNION(int16m1)
DEFINE_UNION(int32m1) DEFINE_UNION(int32m1)
DEFINE_UNION(int64m1) DEFINE_UNION(int64m1)
DEFINE_UNION(uint8m1) DEFINE_UNION(uint8m1)
DEFINE_UNION(uint16m1) DEFINE_UNION(uint16m1)
DEFINE_UNION(uint32m1) DEFINE_UNION(uint32m1)
DEFINE_UNION(uint64m1) DEFINE_UNION(uint64m1)
DEFINE_UNION(float32m1) DEFINE_UNION(float32m1)
DEFINE_UNION(float64m1) 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 // Global variables
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
fixed_int8m1_t global_i8; fixed_int8m1_t global_i8;
fixed_int16m1_t global_i16; fixed_int16m1_t global_i16;
fixed_int32m1_t global_i32; fixed_int32m1_t global_i32;
fixed_int64m1_t global_i64; fixed_int64m1_t global_i64;
fixed_uint8m1_t global_u8; fixed_uint8m1_t global_u8;
fixed_uint16m1_t global_u16; fixed_uint16m1_t global_u16;
fixed_uint32m1_t global_u32; fixed_uint32m1_t global_u32;
fixed_uint64m1_t global_u64; fixed_uint64m1_t global_u64;
fixed_float32m1_t global_f32; fixed_float32m1_t global_f32;
fixed_float64m1_t global_f64; 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 // Global arrays
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
fixed_int8m1_t global_arr_i8[3]; fixed_int8m1_t global_arr_i8[3];
fixed_int16m1_t global_arr_i16[3]; fixed_int16m1_t global_arr_i16[3];
fixed_int32m1_t global_arr_i32[3]; fixed_int32m1_t global_arr_i32[3];
fixed_int64m1_t global_arr_i64[3]; fixed_int64m1_t global_arr_i64[3];
fixed_uint8m1_t global_arr_u8[3]; fixed_uint8m1_t global_arr_u8[3];
fixed_uint16m1_t global_arr_u16[3]; fixed_uint16m1_t global_arr_u16[3];
fixed_uint32m1_t global_arr_u32[3]; fixed_uint32m1_t global_arr_u32[3];
fixed_uint64m1_t global_arr_u64[3]; fixed_uint64m1_t global_arr_u64[3];
fixed_float32m1_t global_arr_f32[3]; fixed_float32m1_t global_arr_f32[3];
fixed_float64m1_t global_arr_f64[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 // Locals
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void f() { void f() {
// Variables // Variables
fixed_int8m1_t local_i8; fixed_int8m1_t local_i8;
fixed_int16m1_t local_i16; fixed_int16m1_t local_i16;
fixed_int32m1_t local_i32; fixed_int32m1_t local_i32;
fixed_int64m1_t local_i64; fixed_int64m1_t local_i64;
fixed_uint8m1_t local_u8; fixed_uint8m1_t local_u8;
fixed_uint16m1_t local_u16; fixed_uint16m1_t local_u16;
fixed_uint32m1_t local_u32; fixed_uint32m1_t local_u32;
fixed_uint64m1_t local_u64; fixed_uint64m1_t local_u64;
fixed_float32m1_t local_f32; fixed_float32m1_t local_f32;
fixed_float64m1_t local_f64; 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 // Arrays
fixed_int8m1_t local_arr_i8[3]; fixed_int8m1_t local_arr_i8[3];
fixed_int16m1_t local_arr_i16[3]; fixed_int16m1_t local_arr_i16[3];
fixed_int32m1_t local_arr_i32[3]; fixed_int32m1_t local_arr_i32[3];
fixed_int64m1_t local_arr_i64[3]; fixed_int64m1_t local_arr_i64[3];
fixed_uint8m1_t local_arr_u8[3]; fixed_uint8m1_t local_arr_u8[3];
fixed_uint16m1_t local_arr_u16[3]; fixed_uint16m1_t local_arr_u16[3];
fixed_uint32m1_t local_arr_u32[3]; fixed_uint32m1_t local_arr_u32[3];
fixed_uint64m1_t local_arr_u64[3]; fixed_uint64m1_t local_arr_u64[3];
fixed_float32m1_t local_arr_f32[3]; fixed_float32m1_t local_arr_f32[3];
fixed_float64m1_t local_arr_f64[3]; fixed_float64m1_t local_arr_f64[3];
fixed_int8m2_t local_arr_i8m2[3];
fixed_int16m2_t local_arr_i16m2[3];
fixed_int32m2_t local_arr_i32m2[3];
fixed_int64m2_t local_arr_i64m2[3];
fixed_uint8m2_t local_arr_u8m2[3];
fixed_uint16m2_t local_arr_u16m2[3];
fixed_uint32m2_t local_arr_u32m2[3];
fixed_uint64m2_t local_arr_u64m2[3];
fixed_float32m2_t local_arr_f32m2[3];
fixed_float64m2_t local_arr_f64m2[3];
fixed_int8m4_t local_arr_i8m4[3];
fixed_int16m4_t local_arr_i16m4[3];
fixed_int32m4_t local_arr_i32m4[3];
fixed_int64m4_t local_arr_i64m4[3];
fixed_uint8m4_t local_arr_u8m4[3];
fixed_uint16m4_t local_arr_u16m4[3];
fixed_uint32m4_t local_arr_u32m4[3];
fixed_uint64m4_t local_arr_u64m4[3];
fixed_float32m4_t local_arr_f32m4[3];
fixed_float64m4_t local_arr_f64m4[3];
fixed_int8m8_t local_arr_i8m8[3];
fixed_int16m8_t local_arr_i16m8[3];
fixed_int32m8_t local_arr_i32m8[3];
fixed_int64m8_t local_arr_i64m8[3];
fixed_uint8m8_t local_arr_u8m8[3];
fixed_uint16m8_t local_arr_u16m8[3];
fixed_uint32m8_t local_arr_u32m8[3];
fixed_uint64m8_t local_arr_u64m8[3];
fixed_float32m8_t local_arr_f32m8[3];
fixed_float64m8_t local_arr_f64m8[3];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Structs and unions // Structs and unions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-64: %struct.struct_int8m1 = type { <8 x i8> } // CHECK-64: %struct.struct_int8m1 = type { <8 x i8> }
// CHECK-64-NEXT: %struct.struct_int16m1 = type { <4 x i16> } // CHECK-64-NEXT: %struct.struct_int16m1 = type { <4 x i16> }
// CHECK-64-NEXT: %struct.struct_int32m1 = type { <2 x i32> } // CHECK-64-NEXT: %struct.struct_int32m1 = type { <2 x i32> }
// CHECK-64-NEXT: %struct.struct_int64m1 = type { <1 x i64> } // CHECK-64-NEXT: %struct.struct_int64m1 = type { <1 x i64> }
// CHECK-64-NEXT: %struct.struct_uint8m1 = type { <8 x i8> } // CHECK-64-NEXT: %struct.struct_uint8m1 = type { <8 x i8> }
// CHECK-64-NEXT: %struct.struct_uint16m1 = type { <4 x i16> } // CHECK-64-NEXT: %struct.struct_uint16m1 = type { <4 x i16> }
// CHECK-64-NEXT: %struct.struct_uint32m1 = type { <2 x i32> } // CHECK-64-NEXT: %struct.struct_uint32m1 = type { <2 x i32> }
// CHECK-64-NEXT: %struct.struct_uint64m1 = type { <1 x i64> } // 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_float32m1 = type { <2 x float> }
// CHECK-64-NEXT: %struct.struct_float64m1 = type { <1 x double> } // 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: %struct.struct_int8m1 = type { <16 x i8> }
// CHECK-128-NEXT: %struct.struct_int16m1 = type { <8 x i16> } // CHECK-128-NEXT: %struct.struct_int16m1 = type { <8 x i16> }
// CHECK-128-NEXT: %struct.struct_int32m1 = type { <4 x i32> } // CHECK-128-NEXT: %struct.struct_int32m1 = type { <4 x i32> }
// CHECK-128-NEXT: %struct.struct_int64m1 = type { <2 x i64> } // CHECK-128-NEXT: %struct.struct_int64m1 = type { <2 x i64> }
// CHECK-128-NEXT: %struct.struct_uint8m1 = type { <16 x i8> } // CHECK-128-NEXT: %struct.struct_uint8m1 = type { <16 x i8> }
// CHECK-128-NEXT: %struct.struct_uint16m1 = type { <8 x i16> } // CHECK-128-NEXT: %struct.struct_uint16m1 = type { <8 x i16> }
// CHECK-128-NEXT: %struct.struct_uint32m1 = type { <4 x i32> } // CHECK-128-NEXT: %struct.struct_uint32m1 = type { <4 x i32> }
// CHECK-128-NEXT: %struct.struct_uint64m1 = type { <2 x i64> } // 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_float32m1 = type { <4 x float> }
// CHECK-128-NEXT: %struct.struct_float64m1 = type { <2 x double> } // 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: %struct.struct_int8m1 = type { <32 x i8> }
// CHECK-256-NEXT: %struct.struct_int16m1 = type { <16 x i16> } // CHECK-256-NEXT: %struct.struct_int16m1 = type { <16 x i16> }
// CHECK-256-NEXT: %struct.struct_int32m1 = type { <8 x i32> } // CHECK-256-NEXT: %struct.struct_int32m1 = type { <8 x i32> }
// CHECK-256-NEXT: %struct.struct_int64m1 = type { <4 x i64> } // CHECK-256-NEXT: %struct.struct_int64m1 = type { <4 x i64> }
// CHECK-256-NEXT: %struct.struct_uint8m1 = type { <32 x i8> } // CHECK-256-NEXT: %struct.struct_uint8m1 = type { <32 x i8> }
// CHECK-256-NEXT: %struct.struct_uint16m1 = type { <16 x i16> } // CHECK-256-NEXT: %struct.struct_uint16m1 = type { <16 x i16> }
// CHECK-256-NEXT: %struct.struct_uint32m1 = type { <8 x i32> } // CHECK-256-NEXT: %struct.struct_uint32m1 = type { <8 x i32> }
// CHECK-256-NEXT: %struct.struct_uint64m1 = type { <4 x i64> } // 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_float32m1 = type { <8 x float> }
// CHECK-256-NEXT: %struct.struct_float64m1 = type { <4 x double> } // 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: %struct.struct_int8m1 = type { <64 x i8> }
// CHECK-512-NEXT: %struct.struct_int16m1 = type { <32 x i16> } // CHECK-512-NEXT: %struct.struct_int16m1 = type { <32 x i16> }
// CHECK-512-NEXT: %struct.struct_int32m1 = type { <16 x i32> } // CHECK-512-NEXT: %struct.struct_int32m1 = type { <16 x i32> }
// CHECK-512-NEXT: %struct.struct_int64m1 = type { <8 x i64> } // CHECK-512-NEXT: %struct.struct_int64m1 = type { <8 x i64> }
// CHECK-512-NEXT: %struct.struct_uint8m1 = type { <64 x i8> } // CHECK-512-NEXT: %struct.struct_uint8m1 = type { <64 x i8> }
// CHECK-512-NEXT: %struct.struct_uint16m1 = type { <32 x i16> } // CHECK-512-NEXT: %struct.struct_uint16m1 = type { <32 x i16> }
// CHECK-512-NEXT: %struct.struct_uint32m1 = type { <16 x i32> } // CHECK-512-NEXT: %struct.struct_uint32m1 = type { <16 x i32> }
// CHECK-512-NEXT: %struct.struct_uint64m1 = type { <8 x i64> } // 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_float32m1 = type { <16 x float> }
// CHECK-512-NEXT: %struct.struct_float64m1 = type { <8 x double> } // 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: %struct.struct_int8m1 = type { <128 x i8> }
// CHECK-1024-NEXT: %struct.struct_int16m1 = type { <64 x i16> } // CHECK-1024-NEXT: %struct.struct_int16m1 = type { <64 x i16> }
// CHECK-1024-NEXT: %struct.struct_int32m1 = type { <32 x i32> } // CHECK-1024-NEXT: %struct.struct_int32m1 = type { <32 x i32> }
// CHECK-1024-NEXT: %struct.struct_int64m1 = type { <16 x i64> } // CHECK-1024-NEXT: %struct.struct_int64m1 = type { <16 x i64> }
// CHECK-1024-NEXT: %struct.struct_uint8m1 = type { <128 x i8> } // CHECK-1024-NEXT: %struct.struct_uint8m1 = type { <128 x i8> }
// CHECK-1024-NEXT: %struct.struct_uint16m1 = type { <64 x i16> } // CHECK-1024-NEXT: %struct.struct_uint16m1 = type { <64 x i16> }
// CHECK-1024-NEXT: %struct.struct_uint32m1 = type { <32 x i32> } // CHECK-1024-NEXT: %struct.struct_uint32m1 = type { <32 x i32> }
// CHECK-1024-NEXT: %struct.struct_uint64m1 = type { <16 x i64> } // 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_float32m1 = type { <32 x float> }
// CHECK-1024-NEXT: %struct.struct_float64m1 = type { <16 x double> } // 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: %union.union_int8m1 = type { <8 x i8> }
// CHECK-64-NEXT: %union.union_int16m1 = type { <4 x i16> } // CHECK-64-NEXT: %union.union_int16m1 = type { <4 x i16> }
// CHECK-64-NEXT: %union.union_int32m1 = type { <2 x i32> } // CHECK-64-NEXT: %union.union_int32m1 = type { <2 x i32> }
// CHECK-64-NEXT: %union.union_int64m1 = type { <1 x i64> } // CHECK-64-NEXT: %union.union_int64m1 = type { <1 x i64> }
// CHECK-64-NEXT: %union.union_uint8m1 = type { <8 x i8> } // CHECK-64-NEXT: %union.union_uint8m1 = type { <8 x i8> }
// CHECK-64-NEXT: %union.union_uint16m1 = type { <4 x i16> } // CHECK-64-NEXT: %union.union_uint16m1 = type { <4 x i16> }
// CHECK-64-NEXT: %union.union_uint32m1 = type { <2 x i32> } // CHECK-64-NEXT: %union.union_uint32m1 = type { <2 x i32> }
// CHECK-64-NEXT: %union.union_uint64m1 = type { <1 x i64> } // 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_float32m1 = type { <2 x float> }
// CHECK-64-NEXT: %union.union_float64m1 = type { <1 x double> } // 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: %union.union_int8m1 = type { <16 x i8> }
// CHECK-128-NEXT: %union.union_int16m1 = type { <8 x i16> } // CHECK-128-NEXT: %union.union_int16m1 = type { <8 x i16> }
// CHECK-128-NEXT: %union.union_int32m1 = type { <4 x i32> } // CHECK-128-NEXT: %union.union_int32m1 = type { <4 x i32> }
// CHECK-128-NEXT: %union.union_int64m1 = type { <2 x i64> } // CHECK-128-NEXT: %union.union_int64m1 = type { <2 x i64> }
// CHECK-128-NEXT: %union.union_uint8m1 = type { <16 x i8> } // CHECK-128-NEXT: %union.union_uint8m1 = type { <16 x i8> }
// CHECK-128-NEXT: %union.union_uint16m1 = type { <8 x i16> } // CHECK-128-NEXT: %union.union_uint16m1 = type { <8 x i16> }
// CHECK-128-NEXT: %union.union_uint32m1 = type { <4 x i32> } // CHECK-128-NEXT: %union.union_uint32m1 = type { <4 x i32> }
// CHECK-128-NEXT: %union.union_uint64m1 = type { <2 x i64> } // 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_float32m1 = type { <4 x float> }
// CHECK-128-NEXT: %union.union_float64m1 = type { <2 x double> } // 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: %union.union_int8m1 = type { <32 x i8> }
// CHECK-256-NEXT: %union.union_int16m1 = type { <16 x i16> } // CHECK-256-NEXT: %union.union_int16m1 = type { <16 x i16> }
// CHECK-256-NEXT: %union.union_int32m1 = type { <8 x i32> } // CHECK-256-NEXT: %union.union_int32m1 = type { <8 x i32> }
// CHECK-256-NEXT: %union.union_int64m1 = type { <4 x i64> } // CHECK-256-NEXT: %union.union_int64m1 = type { <4 x i64> }
// CHECK-256-NEXT: %union.union_uint8m1 = type { <32 x i8> } // CHECK-256-NEXT: %union.union_uint8m1 = type { <32 x i8> }
// CHECK-256-NEXT: %union.union_uint16m1 = type { <16 x i16> } // CHECK-256-NEXT: %union.union_uint16m1 = type { <16 x i16> }
// CHECK-256-NEXT: %union.union_uint32m1 = type { <8 x i32> } // CHECK-256-NEXT: %union.union_uint32m1 = type { <8 x i32> }
// CHECK-256-NEXT: %union.union_uint64m1 = type { <4 x i64> } // 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_float32m1 = type { <8 x float> }
// CHECK-256-NEXT: %union.union_float64m1 = type { <4 x double> } // 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: %union.union_int8m1 = type { <64 x i8> }
// CHECK-512-NEXT: %union.union_int16m1 = type { <32 x i16> } // CHECK-512-NEXT: %union.union_int16m1 = type { <32 x i16> }
// CHECK-512-NEXT: %union.union_int32m1 = type { <16 x i32> } // CHECK-512-NEXT: %union.union_int32m1 = type { <16 x i32> }
// CHECK-512-NEXT: %union.union_int64m1 = type { <8 x i64> } // CHECK-512-NEXT: %union.union_int64m1 = type { <8 x i64> }
// CHECK-512-NEXT: %union.union_uint8m1 = type { <64 x i8> } // CHECK-512-NEXT: %union.union_uint8m1 = type { <64 x i8> }
// CHECK-512-NEXT: %union.union_uint16m1 = type { <32 x i16> } // CHECK-512-NEXT: %union.union_uint16m1 = type { <32 x i16> }
// CHECK-512-NEXT: %union.union_uint32m1 = type { <16 x i32> } // CHECK-512-NEXT: %union.union_uint32m1 = type { <16 x i32> }
// CHECK-512-NEXT: %union.union_uint64m1 = type { <8 x i64> } // 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_float32m1 = type { <16 x float> }
// CHECK-512-NEXT: %union.union_float64m1 = type { <8 x double> } // 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: %union.union_int8m1 = type { <128 x i8> }
// CHECK-1024-NEXT: %union.union_int16m1 = type { <64 x i16> } // CHECK-1024-NEXT: %union.union_int16m1 = type { <64 x i16> }
// CHECK-1024-NEXT: %union.union_int32m1 = type { <32 x i32> } // CHECK-1024-NEXT: %union.union_int32m1 = type { <32 x i32> }
// CHECK-1024-NEXT: %union.union_int64m1 = type { <16 x i64> } // CHECK-1024-NEXT: %union.union_int64m1 = type { <16 x i64> }
// CHECK-1024-NEXT: %union.union_uint8m1 = type { <128 x i8> } // CHECK-1024-NEXT: %union.union_uint8m1 = type { <128 x i8> }
// CHECK-1024-NEXT: %union.union_uint16m1 = type { <64 x i16> } // CHECK-1024-NEXT: %union.union_uint16m1 = type { <64 x i16> }
// CHECK-1024-NEXT: %union.union_uint32m1 = type { <32 x i32> } // CHECK-1024-NEXT: %union.union_uint32m1 = type { <32 x i32> }
// CHECK-1024-NEXT: %union.union_uint64m1 = type { <16 x i64> } // 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_float32m1 = type { <32 x float> }
// CHECK-1024-NEXT: %union.union_float64m1 = type { <16 x double> } // 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 // Global variables
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-64: @global_i8 ={{.*}} global <8 x i8> zeroinitializer, align 8 // CHECK-64: @global_i8 ={{.*}} global <8 x i8> zeroinitializer, align 8
// CHECK-64-NEXT: @global_i16 ={{.*}} global <4 x i16> zeroinitializer, align 8 // CHECK-64-NEXT: @global_i16 ={{.*}} global <4 x i16> zeroinitializer, align 8
// CHECK-64-NEXT: @global_i32 ={{.*}} global <2 x i32> zeroinitializer, align 8 // CHECK-64-NEXT: @global_i32 ={{.*}} global <2 x i32> zeroinitializer, align 8
// CHECK-64-NEXT: @global_i64 ={{.*}} global <1 x i64> zeroinitializer, align 8 // CHECK-64-NEXT: @global_i64 ={{.*}} global <1 x i64> zeroinitializer, align 8
// CHECK-64-NEXT: @global_u8 ={{.*}} global <8 x i8> zeroinitializer, align 8 // CHECK-64-NEXT: @global_u8 ={{.*}} global <8 x i8> zeroinitializer, align 8
// CHECK-64-NEXT: @global_u16 ={{.*}} global <4 x i16> zeroinitializer, align 8 // CHECK-64-NEXT: @global_u16 ={{.*}} global <4 x i16> zeroinitializer, align 8
// CHECK-64-NEXT: @global_u32 ={{.*}} global <2 x i32> zeroinitializer, align 8 // CHECK-64-NEXT: @global_u32 ={{.*}} global <2 x i32> zeroinitializer, align 8
// CHECK-64-NEXT: @global_u64 ={{.*}} global <1 x i64> zeroinitializer, align 8 // CHECK-64-NEXT: @global_u64 ={{.*}} global <1 x i64> zeroinitializer, align 8
// CHECK-64-NEXT: @global_f32 ={{.*}} global <2 x float> 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_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: @global_i8 ={{.*}} global <16 x i8> zeroinitializer, align 8
// CHECK-128-NEXT: @global_i16 ={{.*}} global <8 x i16> zeroinitializer, align 8 // CHECK-128-NEXT: @global_i16 ={{.*}} global <8 x i16> zeroinitializer, align 8
// CHECK-128-NEXT: @global_i32 ={{.*}} global <4 x i32> zeroinitializer, align 8 // CHECK-128-NEXT: @global_i32 ={{.*}} global <4 x i32> zeroinitializer, align 8
// CHECK-128-NEXT: @global_i64 ={{.*}} global <2 x i64> zeroinitializer, align 8 // CHECK-128-NEXT: @global_i64 ={{.*}} global <2 x i64> zeroinitializer, align 8
// CHECK-128-NEXT: @global_u8 ={{.*}} global <16 x i8> zeroinitializer, align 8 // CHECK-128-NEXT: @global_u8 ={{.*}} global <16 x i8> zeroinitializer, align 8
// CHECK-128-NEXT: @global_u16 ={{.*}} global <8 x i16> zeroinitializer, align 8 // CHECK-128-NEXT: @global_u16 ={{.*}} global <8 x i16> zeroinitializer, align 8
// CHECK-128-NEXT: @global_u32 ={{.*}} global <4 x i32> zeroinitializer, align 8 // CHECK-128-NEXT: @global_u32 ={{.*}} global <4 x i32> zeroinitializer, align 8
// CHECK-128-NEXT: @global_u64 ={{.*}} global <2 x i64> zeroinitializer, align 8 // CHECK-128-NEXT: @global_u64 ={{.*}} global <2 x i64> zeroinitializer, align 8
// CHECK-128-NEXT: @global_f32 ={{.*}} global <4 x float> 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_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: @global_i8 ={{.*}} global <32 x i8> zeroinitializer, align 8
// CHECK-256-NEXT: @global_i16 ={{.*}} global <16 x i16> zeroinitializer, align 8 // CHECK-256-NEXT: @global_i16 ={{.*}} global <16 x i16> zeroinitializer, align 8
// CHECK-256-NEXT: @global_i32 ={{.*}} global <8 x i32> zeroinitializer, align 8 // CHECK-256-NEXT: @global_i32 ={{.*}} global <8 x i32> zeroinitializer, align 8
// CHECK-256-NEXT: @global_i64 ={{.*}} global <4 x i64> zeroinitializer, align 8 // CHECK-256-NEXT: @global_i64 ={{.*}} global <4 x i64> zeroinitializer, align 8
// CHECK-256-NEXT: @global_u8 ={{.*}} global <32 x i8> zeroinitializer, align 8 // CHECK-256-NEXT: @global_u8 ={{.*}} global <32 x i8> zeroinitializer, align 8
// CHECK-256-NEXT: @global_u16 ={{.*}} global <16 x i16> zeroinitializer, align 8 // CHECK-256-NEXT: @global_u16 ={{.*}} global <16 x i16> zeroinitializer, align 8
// CHECK-256-NEXT: @global_u32 ={{.*}} global <8 x i32> zeroinitializer, align 8 // CHECK-256-NEXT: @global_u32 ={{.*}} global <8 x i32> zeroinitializer, align 8
// CHECK-256-NEXT: @global_u64 ={{.*}} global <4 x i64> zeroinitializer, align 8 // CHECK-256-NEXT: @global_u64 ={{.*}} global <4 x i64> zeroinitializer, align 8
// CHECK-256-NEXT: @global_f32 ={{.*}} global <8 x float> 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_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: @global_i8 ={{.*}} global <64 x i8> zeroinitializer, align 8
// CHECK-512-NEXT: @global_i16 ={{.*}} global <32 x i16> zeroinitializer, align 8 // CHECK-512-NEXT: @global_i16 ={{.*}} global <32 x i16> zeroinitializer, align 8
// CHECK-512-NEXT: @global_i32 ={{.*}} global <16 x i32> zeroinitializer, align 8 // CHECK-512-NEXT: @global_i32 ={{.*}} global <16 x i32> zeroinitializer, align 8
// CHECK-512-NEXT: @global_i64 ={{.*}} global <8 x i64> zeroinitializer, align 8 // CHECK-512-NEXT: @global_i64 ={{.*}} global <8 x i64> zeroinitializer, align 8
// CHECK-512-NEXT: @global_u8 ={{.*}} global <64 x i8> zeroinitializer, align 8 // CHECK-512-NEXT: @global_u8 ={{.*}} global <64 x i8> zeroinitializer, align 8
// CHECK-512-NEXT: @global_u16 ={{.*}} global <32 x i16> zeroinitializer, align 8 // CHECK-512-NEXT: @global_u16 ={{.*}} global <32 x i16> zeroinitializer, align 8
// CHECK-512-NEXT: @global_u32 ={{.*}} global <16 x i32> zeroinitializer, align 8 // CHECK-512-NEXT: @global_u32 ={{.*}} global <16 x i32> zeroinitializer, align 8
// CHECK-512-NEXT: @global_u64 ={{.*}} global <8 x i64> zeroinitializer, align 8 // CHECK-512-NEXT: @global_u64 ={{.*}} global <8 x i64> zeroinitializer, align 8
// CHECK-512-NEXT: @global_f32 ={{.*}} global <16 x float> 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_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: @global_i8 ={{.*}} global <128 x i8> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_i16 ={{.*}} global <64 x i16> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_i16 ={{.*}} global <64 x i16> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_i32 ={{.*}} global <32 x i32> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_i32 ={{.*}} global <32 x i32> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_i64 ={{.*}} global <16 x i64> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_i64 ={{.*}} global <16 x i64> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_u8 ={{.*}} global <128 x i8> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_u8 ={{.*}} global <128 x i8> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_u16 ={{.*}} global <64 x i16> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_u16 ={{.*}} global <64 x i16> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_u32 ={{.*}} global <32 x i32> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_u32 ={{.*}} global <32 x i32> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_u64 ={{.*}} global <16 x i64> zeroinitializer, align 8 // CHECK-1024-NEXT: @global_u64 ={{.*}} global <16 x i64> zeroinitializer, align 8
// CHECK-1024-NEXT: @global_f32 ={{.*}} global <32 x float> 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_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 // Global arrays
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-64: @global_arr_i8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8 // CHECK-64: @global_arr_i8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_i16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_i16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_i32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_i32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_i64 ={{.*}} global [3 x <1 x i64>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_i64 ={{.*}} global [3 x <1 x i64>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_u8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_u8 ={{.*}} global [3 x <8 x i8>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_u16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_u16 ={{.*}} global [3 x <4 x i16>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_u32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_u32 ={{.*}} global [3 x <2 x i32>] zeroinitializer, align 8
// CHECK-64-NEXT: @global_arr_u64 ={{.*}} global [3 x <1 x i64>] zeroinitializer, align 8 // CHECK-64-NEXT: @global_arr_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_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_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: @global_arr_i8 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_i16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_i16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_i32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_i32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_i64 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_i64 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_u8 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_u8 ={{.*}} global [3 x <16 x i8>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_u16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_u16 ={{.*}} global [3 x <8 x i16>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_u32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_u32 ={{.*}} global [3 x <4 x i32>] zeroinitializer, align 8
// CHECK-128-NEXT: @global_arr_u64 ={{.*}} global [3 x <2 x i64>] zeroinitializer, align 8 // CHECK-128-NEXT: @global_arr_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_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_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: @global_arr_i8 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_i16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_i16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_i32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_i32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_i64 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_i64 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_u8 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_u8 ={{.*}} global [3 x <32 x i8>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_u16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_u16 ={{.*}} global [3 x <16 x i16>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_u32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_u32 ={{.*}} global [3 x <8 x i32>] zeroinitializer, align 8
// CHECK-256-NEXT: @global_arr_u64 ={{.*}} global [3 x <4 x i64>] zeroinitializer, align 8 // CHECK-256-NEXT: @global_arr_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_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_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: @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_i16 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_i32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_i32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_i64 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_i64 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_u8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_u8 ={{.*}} global [3 x <64 x i8>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_u16 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_u16 ={{.*}} global [3 x <32 x i16>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_u32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_u32 ={{.*}} global [3 x <16 x i32>] zeroinitializer, align 8
// CHECK-512-NEXT: @global_arr_u64 ={{.*}} global [3 x <8 x i64>] zeroinitializer, align 8 // CHECK-512-NEXT: @global_arr_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_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_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: @global_arr_i8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_i16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_i16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_i32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_i32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_i64 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_i64 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_u8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_u8 ={{.*}} global [3 x <128 x i8>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_u16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_u16 ={{.*}} global [3 x <64 x i16>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_u32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_u32 ={{.*}} global [3 x <32 x i32>] zeroinitializer, align 8
// CHECK-1024-NEXT: @global_arr_u64 ={{.*}} global [3 x <16 x i64>] zeroinitializer, align 8 // CHECK-1024-NEXT: @global_arr_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_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_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 // Local variables
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-64: %local_i8 = alloca <8 x i8>, align 8 // CHECK-64: %local_i8 = alloca <8 x i8>, align 8
// CHECK-64-NEXT: %local_i16 = alloca <4 x i16>, align 8 // CHECK-64-NEXT: %local_i16 = alloca <4 x i16>, align 8
// CHECK-64-NEXT: %local_i32 = alloca <2 x i32>, align 8 // CHECK-64-NEXT: %local_i32 = alloca <2 x i32>, align 8
// CHECK-64-NEXT: %local_i64 = alloca <1 x i64>, align 8 // CHECK-64-NEXT: %local_i64 = alloca <1 x i64>, align 8
// CHECK-64-NEXT: %local_u8 = alloca <8 x i8>, align 8 // CHECK-64-NEXT: %local_u8 = alloca <8 x i8>, align 8
// CHECK-64-NEXT: %local_u16 = alloca <4 x i16>, align 8 // CHECK-64-NEXT: %local_u16 = alloca <4 x i16>, align 8
// CHECK-64-NEXT: %local_u32 = alloca <2 x i32>, align 8 // CHECK-64-NEXT: %local_u32 = alloca <2 x i32>, align 8
// CHECK-64-NEXT: %local_u64 = alloca <1 x i64>, align 8 // CHECK-64-NEXT: %local_u64 = alloca <1 x i64>, align 8
// CHECK-64-NEXT: %local_f32 = alloca <2 x float>, 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_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: %local_i8 = alloca <16 x i8>, align 8
// CHECK-128-NEXT: %local_i16 = alloca <8 x i16>, align 8 // CHECK-128-NEXT: %local_i16 = alloca <8 x i16>, align 8
// CHECK-128-NEXT: %local_i32 = alloca <4 x i32>, align 8 // CHECK-128-NEXT: %local_i32 = alloca <4 x i32>, align 8
// CHECK-128-NEXT: %local_i64 = alloca <2 x i64>, align 8 // CHECK-128-NEXT: %local_i64 = alloca <2 x i64>, align 8
// CHECK-128-NEXT: %local_u8 = alloca <16 x i8>, align 8 // CHECK-128-NEXT: %local_u8 = alloca <16 x i8>, align 8
// CHECK-128-NEXT: %local_u16 = alloca <8 x i16>, align 8 // CHECK-128-NEXT: %local_u16 = alloca <8 x i16>, align 8
// CHECK-128-NEXT: %local_u32 = alloca <4 x i32>, align 8 // CHECK-128-NEXT: %local_u32 = alloca <4 x i32>, align 8
// CHECK-128-NEXT: %local_u64 = alloca <2 x i64>, align 8 // CHECK-128-NEXT: %local_u64 = alloca <2 x i64>, align 8
// CHECK-128-NEXT: %local_f32 = alloca <4 x float>, align 8 // CHECK-128-NEXT: %local_f32 = alloca <4 x float>, align 8
// CHECK-128-NEXT: %local_f64 = alloca <2 x double>, 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: %local_i8 = alloca <32 x i8>, align 8
// CHECK-256-NEXT: %local_i16 = alloca <16 x i16>, align 8 // CHECK-256-NEXT: %local_i16 = alloca <16 x i16>, align 8
// CHECK-256-NEXT: %local_i32 = alloca <8 x i32>, align 8 // CHECK-256-NEXT: %local_i32 = alloca <8 x i32>, align 8
// CHECK-256-NEXT: %local_i64 = alloca <4 x i64>, align 8 // CHECK-256-NEXT: %local_i64 = alloca <4 x i64>, align 8
// CHECK-256-NEXT: %local_u8 = alloca <32 x i8>, align 8 // CHECK-256-NEXT: %local_u8 = alloca <32 x i8>, align 8
// CHECK-256-NEXT: %local_u16 = alloca <16 x i16>, align 8 // CHECK-256-NEXT: %local_u16 = alloca <16 x i16>, align 8
// CHECK-256-NEXT: %local_u32 = alloca <8 x i32>, align 8 // CHECK-256-NEXT: %local_u32 = alloca <8 x i32>, align 8
// CHECK-256-NEXT: %local_u64 = alloca <4 x i64>, align 8 // CHECK-256-NEXT: %local_u64 = alloca <4 x i64>, align 8
// CHECK-256-NEXT: %local_f32 = alloca <8 x float>, align 8 // CHECK-256-NEXT: %local_f32 = alloca <8 x float>, align 8
// CHECK-256-NEXT: %local_f64 = alloca <4 x double>, 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: %local_i8 = alloca <64 x i8>, align 8
// CHECK-512-NEXT: %local_i16 = alloca <32 x i16>, align 8 // CHECK-512-NEXT: %local_i16 = alloca <32 x i16>, align 8
// CHECK-512-NEXT: %local_i32 = alloca <16 x i32>, align 8 // CHECK-512-NEXT: %local_i32 = alloca <16 x i32>, align 8
// CHECK-512-NEXT: %local_i64 = alloca <8 x i64>, align 8 // CHECK-512-NEXT: %local_i64 = alloca <8 x i64>, align 8
// CHECK-512-NEXT: %local_u8 = alloca <64 x i8>, align 8 // CHECK-512-NEXT: %local_u8 = alloca <64 x i8>, align 8
// CHECK-512-NEXT: %local_u16 = alloca <32 x i16>, align 8 // CHECK-512-NEXT: %local_u16 = alloca <32 x i16>, align 8
// CHECK-512-NEXT: %local_u32 = alloca <16 x i32>, align 8 // CHECK-512-NEXT: %local_u32 = alloca <16 x i32>, align 8
// CHECK-512-NEXT: %local_u64 = alloca <8 x i64>, align 8 // CHECK-512-NEXT: %local_u64 = alloca <8 x i64>, align 8
// CHECK-512-NEXT: %local_f32 = alloca <16 x float>, align 8 // CHECK-512-NEXT: %local_f32 = alloca <16 x float>, align 8
// CHECK-512-NEXT: %local_f64 = alloca <8 x double>, 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: %local_i8 = alloca <128 x i8>, align 8
// CHECK-1024-NEXT: %local_i16 = alloca <64 x i16>, align 8 // CHECK-1024-NEXT: %local_i16 = alloca <64 x i16>, align 8
// CHECK-1024-NEXT: %local_i32 = alloca <32 x i32>, align 8 // CHECK-1024-NEXT: %local_i32 = alloca <32 x i32>, align 8
// CHECK-1024-NEXT: %local_i64 = alloca <16 x i64>, align 8 // CHECK-1024-NEXT: %local_i64 = alloca <16 x i64>, align 8
// CHECK-1024-NEXT: %local_u8 = alloca <128 x i8>, align 8 // CHECK-1024-NEXT: %local_u8 = alloca <128 x i8>, align 8
// CHECK-1024-NEXT: %local_u16 = alloca <64 x i16>, align 8 // CHECK-1024-NEXT: %local_u16 = alloca <64 x i16>, align 8
// CHECK-1024-NEXT: %local_u32 = alloca <32 x i32>, align 8 // CHECK-1024-NEXT: %local_u32 = alloca <32 x i32>, align 8
// CHECK-1024-NEXT: %local_u64 = alloca <16 x i64>, align 8 // CHECK-1024-NEXT: %local_u64 = alloca <16 x i64>, align 8
// CHECK-1024-NEXT: %local_f32 = alloca <32 x float>, align 8 // CHECK-1024-NEXT: %local_f32 = alloca <32 x float>, align 8
// CHECK-1024-NEXT: %local_f64 = alloca <16 x double>, 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 // Local arrays
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-64: %local_arr_i8 = alloca [3 x <8 x i8>], align 8 // CHECK-64: %local_arr_i8 = alloca [3 x <8 x i8>], align 8
// CHECK-64-NEXT: %local_arr_i16 = alloca [3 x <4 x i16>], align 8 // CHECK-64-NEXT: %local_arr_i16 = alloca [3 x <4 x i16>], align 8
// CHECK-64-NEXT: %local_arr_i32 = alloca [3 x <2 x i32>], align 8 // CHECK-64-NEXT: %local_arr_i32 = alloca [3 x <2 x i32>], align 8
// CHECK-64-NEXT: %local_arr_i64 = alloca [3 x <1 x i64>], align 8 // CHECK-64-NEXT: %local_arr_i64 = alloca [3 x <1 x i64>], align 8
// CHECK-64-NEXT: %local_arr_u8 = alloca [3 x <8 x i8>], align 8 // CHECK-64-NEXT: %local_arr_u8 = alloca [3 x <8 x i8>], align 8
// CHECK-64-NEXT: %local_arr_u16 = alloca [3 x <4 x i16>], align 8 // CHECK-64-NEXT: %local_arr_u16 = alloca [3 x <4 x i16>], align 8
// CHECK-64-NEXT: %local_arr_u32 = alloca [3 x <2 x i32>], align 8 // CHECK-64-NEXT: %local_arr_u32 = alloca [3 x <2 x i32>], align 8
// CHECK-64-NEXT: %local_arr_u64 = alloca [3 x <1 x i64>], align 8 // CHECK-64-NEXT: %local_arr_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_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_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: %local_arr_i8 = alloca [3 x <16 x i8>], align 8
// CHECK-128-NEXT: %local_arr_i16 = alloca [3 x <8 x i16>], align 8 // CHECK-128-NEXT: %local_arr_i16 = alloca [3 x <8 x i16>], align 8
// CHECK-128-NEXT: %local_arr_i32 = alloca [3 x <4 x i32>], align 8 // CHECK-128-NEXT: %local_arr_i32 = alloca [3 x <4 x i32>], align 8
// CHECK-128-NEXT: %local_arr_i64 = alloca [3 x <2 x i64>], align 8 // CHECK-128-NEXT: %local_arr_i64 = alloca [3 x <2 x i64>], align 8
// CHECK-128-NEXT: %local_arr_u8 = alloca [3 x <16 x i8>], align 8 // CHECK-128-NEXT: %local_arr_u8 = alloca [3 x <16 x i8>], align 8
// CHECK-128-NEXT: %local_arr_u16 = alloca [3 x <8 x i16>], align 8 // CHECK-128-NEXT: %local_arr_u16 = alloca [3 x <8 x i16>], align 8
// CHECK-128-NEXT: %local_arr_u32 = alloca [3 x <4 x i32>], align 8 // CHECK-128-NEXT: %local_arr_u32 = alloca [3 x <4 x i32>], align 8
// CHECK-128-NEXT: %local_arr_u64 = alloca [3 x <2 x i64>], align 8 // CHECK-128-NEXT: %local_arr_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_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_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: %local_arr_i8 = alloca [3 x <32 x i8>], align 8
// CHECK-256-NEXT: %local_arr_i16 = alloca [3 x <16 x i16>], align 8 // CHECK-256-NEXT: %local_arr_i16 = alloca [3 x <16 x i16>], align 8
// CHECK-256-NEXT: %local_arr_i32 = alloca [3 x <8 x i32>], align 8 // CHECK-256-NEXT: %local_arr_i32 = alloca [3 x <8 x i32>], align 8
// CHECK-256-NEXT: %local_arr_i64 = alloca [3 x <4 x i64>], align 8 // CHECK-256-NEXT: %local_arr_i64 = alloca [3 x <4 x i64>], align 8
// CHECK-256-NEXT: %local_arr_u8 = alloca [3 x <32 x i8>], align 8 // CHECK-256-NEXT: %local_arr_u8 = alloca [3 x <32 x i8>], align 8
// CHECK-256-NEXT: %local_arr_u16 = alloca [3 x <16 x i16>], align 8 // CHECK-256-NEXT: %local_arr_u16 = alloca [3 x <16 x i16>], align 8
// CHECK-256-NEXT: %local_arr_u32 = alloca [3 x <8 x i32>], align 8 // CHECK-256-NEXT: %local_arr_u32 = alloca [3 x <8 x i32>], align 8
// CHECK-256-NEXT: %local_arr_u64 = alloca [3 x <4 x i64>], align 8 // CHECK-256-NEXT: %local_arr_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_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_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: %local_arr_i8 = alloca [3 x <64 x i8>], align 8
// CHECK-512-NEXT: %local_arr_i16 = alloca [3 x <32 x i16>], align 8 // CHECK-512-NEXT: %local_arr_i16 = alloca [3 x <32 x i16>], align 8
// CHECK-512-NEXT: %local_arr_i32 = alloca [3 x <16 x i32>], align 8 // CHECK-512-NEXT: %local_arr_i32 = alloca [3 x <16 x i32>], align 8
// CHECK-512-NEXT: %local_arr_i64 = alloca [3 x <8 x i64>], align 8 // CHECK-512-NEXT: %local_arr_i64 = alloca [3 x <8 x i64>], align 8
// CHECK-512-NEXT: %local_arr_u8 = alloca [3 x <64 x i8>], align 8 // CHECK-512-NEXT: %local_arr_u8 = alloca [3 x <64 x i8>], align 8
// CHECK-512-NEXT: %local_arr_u16 = alloca [3 x <32 x i16>], align 8 // CHECK-512-NEXT: %local_arr_u16 = alloca [3 x <32 x i16>], align 8
// CHECK-512-NEXT: %local_arr_u32 = alloca [3 x <16 x i32>], align 8 // CHECK-512-NEXT: %local_arr_u32 = alloca [3 x <16 x i32>], align 8
// CHECK-512-NEXT: %local_arr_u64 = alloca [3 x <8 x i64>], align 8 // CHECK-512-NEXT: %local_arr_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_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_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: %local_arr_i8 = alloca [3 x <128 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_i16 = alloca [3 x <64 x i16>], align 8 // CHECK-1024-NEXT: %local_arr_i16 = alloca [3 x <64 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_i32 = alloca [3 x <32 x i32>], align 8 // CHECK-1024-NEXT: %local_arr_i32 = alloca [3 x <32 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_i64 = alloca [3 x <16 x i64>], align 8 // CHECK-1024-NEXT: %local_arr_i64 = alloca [3 x <16 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_u8 = alloca [3 x <128 x i8>], align 8 // CHECK-1024-NEXT: %local_arr_u8 = alloca [3 x <128 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_u16 = alloca [3 x <64 x i16>], align 8 // CHECK-1024-NEXT: %local_arr_u16 = alloca [3 x <64 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_u32 = alloca [3 x <32 x i32>], align 8 // CHECK-1024-NEXT: %local_arr_u32 = alloca [3 x <32 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_u64 = alloca [3 x <16 x i64>], align 8 // CHECK-1024-NEXT: %local_arr_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_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_f64 = alloca [3 x <16 x double>], align 8
// CHECK-1024-NEXT: %local_arr_i8m2 = alloca [3 x <256 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_i16m2 = alloca [3 x <128 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_i32m2 = alloca [3 x <64 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_i64m2 = alloca [3 x <32 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_u8m2 = alloca [3 x <256 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_u16m2 = alloca [3 x <128 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_u32m2 = alloca [3 x <64 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_u64m2 = alloca [3 x <32 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_f32m2 = alloca [3 x <64 x float>], align 8
// CHECK-1024-NEXT: %local_arr_f64m2 = alloca [3 x <32 x double>], align 8
// CHECK-1024-NEXT: %local_arr_i8m4 = alloca [3 x <512 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_i16m4 = alloca [3 x <256 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_i32m4 = alloca [3 x <128 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_i64m4 = alloca [3 x <64 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_u8m4 = alloca [3 x <512 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_u16m4 = alloca [3 x <256 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_u32m4 = alloca [3 x <128 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_u64m4 = alloca [3 x <64 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_f32m4 = alloca [3 x <128 x float>], align 8
// CHECK-1024-NEXT: %local_arr_f64m4 = alloca [3 x <64 x double>], align 8
// CHECK-1024-NEXT: %local_arr_i8m8 = alloca [3 x <1024 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_i16m8 = alloca [3 x <512 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_i32m8 = alloca [3 x <256 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_i64m8 = alloca [3 x <128 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_u8m8 = alloca [3 x <1024 x i8>], align 8
// CHECK-1024-NEXT: %local_arr_u16m8 = alloca [3 x <512 x i16>], align 8
// CHECK-1024-NEXT: %local_arr_u32m8 = alloca [3 x <256 x i32>], align 8
// CHECK-1024-NEXT: %local_arr_u64m8 = alloca [3 x <128 x i64>], align 8
// CHECK-1024-NEXT: %local_arr_f32m8 = alloca [3 x <256 x float>], align 8
// CHECK-1024-NEXT: %local_arr_f64m8 = alloca [3 x <128 x double>], align 8

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

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

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

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
typedef __rvv_int32m8_t vint32m8_t; typedef __rvv_int32m8_t vint32m8_t;
typedef __rvv_uint32m8_t vuint32m8_t; typedef __rvv_uint32m8_t vuint32m8_t;
typedef __rvv_int64m8_t vint64m8_t; typedef __rvv_int64m8_t vint64m8_t;
typedef __rvv_uint64m8_t vuint64m8_t; typedef __rvv_uint64m8_t vuint64m8_t;
typedef __rvv_float32m8_t vfloat32m8_t; typedef __rvv_float32m8_t vfloat32m8_t;
typedef __rvv_float64m8_t vfloat64m8_t; typedef __rvv_float64m8_t vfloat64m8_t;
// Define valid fixed-width RVV types // 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 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 vint16m1_t fixed_int16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vint32m1_t fixed_int32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vint64m1_t fixed_int64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint8m1_t fixed_uint8m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint16m1_t fixed_uint16m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint32m1_t fixed_uint32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef vuint64m1_t fixed_uint64m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
typedef vfloat32m1_t fixed_float32m1_t __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); typedef 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 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 // 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 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 int16_t gnu_int16m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef int32_t gnu_int32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef int32_t gnu_int32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef int64_t gnu_int64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef int64_t gnu_int64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef uint8_t gnu_uint8m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef uint8_t gnu_uint8m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef uint16_t gnu_uint16m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef uint16_t gnu_uint16m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef uint32_t gnu_uint32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef uint32_t gnu_uint32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef uint64_t gnu_uint64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef uint64_t gnu_uint64m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8)));
typedef float gnu_float32m1_t __attribute__((vector_size(__riscv_v_fixed_vlen / 8))); typedef 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 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 // Attribute must have a single argument
typedef vint8m1_t no_argument __attribute__((riscv_rvv_vector_bits)); // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}} typedef vint8m1_t no_argument __attribute__((riscv_rvv_vector_bits)); // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}}
typedef vint8m1_t two_arguments __attribute__((riscv_rvv_vector_bits(2, 4))); // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}} typedef vint8m1_t two_arguments __attribute__((riscv_rvv_vector_bits(2, 4))); // expected-error {{'riscv_rvv_vector_bits' attribute takes one argument}}
// The number of RVV vector bits must be an integer constant expression // The number of RVV vector bits must be an integer constant expression
typedef vint8m1_t non_int_size1 __attribute__((riscv_rvv_vector_bits(2.0))); // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}} typedef vint8m1_t non_int_size1 __attribute__((riscv_rvv_vector_bits(2.0))); // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}}
typedef vint8m1_t non_int_size2 __attribute__((riscv_rvv_vector_bits("256"))); // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}} typedef vint8m1_t non_int_size2 __attribute__((riscv_rvv_vector_bits("256"))); // expected-error {{'riscv_rvv_vector_bits' attribute requires an integer constant}}
// bool types and LMUL != 1 are not supported. // 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 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. // 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 *'}} 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 *'}}
typedef int badtype2 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'int'}} typedef int badtype2 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'int'}}
typedef float badtype3 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'float'}} typedef float badtype3 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute applied to non-RVV type 'float'}}
// Attribute only applies to typedefs. // Attribute only applies to typedefs.
vint8m1_t non_typedef_type __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute only applies to typedefs}} vint8m1_t non_typedef_type __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); // expected-error {{'riscv_rvv_vector_bits' attribute only applies to typedefs}}
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Linesvoid f(int c) {
gs8 = gs8 & fs8; // expected-error {{cannot combine GNU and RVV vectors in expression, result is ambiguous}} gs8 = gs8 & fs8; // expected-error {{cannot combine GNU and RVV vectors in expression, result is ambiguous}}
} }
// --------------------------------------------------------------------------// // --------------------------------------------------------------------------//
// Sizeof // Sizeof
#define VECTOR_SIZE ((__riscv_v_fixed_vlen / 8)) #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_int8m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_int16m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_int16m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_int32m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_int32m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_uint8m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_uint8m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_uint16m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_uint16m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_uint32m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_uint32m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_int64m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_float32m1_t) == VECTOR_SIZE, ""); _Static_assert(sizeof(fixed_float32m1_t) == VECTOR_SIZE, "");
_Static_assert(sizeof(fixed_float64m1_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 // Alignof
#define VECTOR_ALIGN 8 #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_int8m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_int16m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_int16m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_int32m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_int32m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_int64m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_int64m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_uint8m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_uint8m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_uint16m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_uint16m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_uint32m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_uint32m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_uint64m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_uint64m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_float32m1_t) == VECTOR_ALIGN, ""); _Static_assert(__alignof__(fixed_float32m1_t) == VECTOR_ALIGN, "");
_Static_assert(__alignof__(fixed_float64m1_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 // Structs
struct struct_int64 { fixed_int64m1_t x, y[5]; }; struct struct_int64 { fixed_int64m1_t x, y[5]; };
struct struct_float64 { fixed_float64m1_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 // Unions
union union_int64 { fixed_int64m1_t x, y[5]; }; union union_int64 { fixed_int64m1_t x, y[5]; };
union union_float64 { fixed_float64m1_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 // Implicit casts
#define TEST_CAST_COMMON(TYPE) \ #define TEST_CAST_COMMON(TYPE) \
v##TYPE##_t to_v##TYPE##_t_from_fixed(fixed_##TYPE##_t x) { return x; } \ v##TYPE##_t to_v##TYPE##_t_from_fixed(fixed_##TYPE##_t x) { return x; } \
fixed_##TYPE##_t from_##TYPE##_t_to_fixed(v##TYPE##_t x) { return x; } fixed_##TYPE##_t from_##TYPE##_t_to_fixed(v##TYPE##_t x) { return x; }
#define TEST_CAST_GNU(PREFIX, TYPE) \ #define TEST_CAST_GNU(PREFIX, TYPE) \
gnu_##TYPE##_t to_gnu_##TYPE##_t_from_##PREFIX##TYPE##_t(PREFIX##TYPE##_t x) { return x; } \ gnu_##TYPE##_t to_gnu_##TYPE##_t_from_##PREFIX##TYPE##_t(PREFIX##TYPE##_t x) { return x; } \
PREFIX##TYPE##_t from_gnu_##TYPE##_t_to_##PREFIX##TYPE##_t(gnu_##TYPE##_t x) { return x; } PREFIX##TYPE##_t from_gnu_##TYPE##_t_to_##PREFIX##TYPE##_t(gnu_##TYPE##_t x) { return x; }
#define TEST_CAST_VECTOR(TYPE) \ #define TEST_CAST_VECTOR(TYPE) \
TEST_CAST_COMMON(TYPE) \ TEST_CAST_COMMON(TYPE) \
TEST_CAST_GNU(v, TYPE) \ TEST_CAST_GNU(v, TYPE) \
TEST_CAST_GNU(fixed_, 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(int8m1)
TEST_CAST_VECTOR(int16m1) TEST_CAST_VECTOR(int16m1)
TEST_CAST_VECTOR(int32m1) TEST_CAST_VECTOR(int32m1)
TEST_CAST_VECTOR(int64m1) TEST_CAST_VECTOR(int64m1)
TEST_CAST_VECTOR(uint8m1) TEST_CAST_VECTOR(uint8m1)
TEST_CAST_VECTOR(uint16m1) TEST_CAST_VECTOR(uint16m1)
TEST_CAST_VECTOR(uint32m1) TEST_CAST_VECTOR(uint32m1)
TEST_CAST_VECTOR(uint64m1) TEST_CAST_VECTOR(uint64m1)
TEST_CAST_VECTOR(float32m1) TEST_CAST_VECTOR(float32m1)
TEST_CAST_VECTOR(float64m1) TEST_CAST_VECTOR(float64m1)
// Test that casts only work for LMUL=1 types and don't crash. TEST_CAST_VECTOR(int8m2)
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')}} TEST_CAST_VECTOR(int16m2)
TEST_CAST_VECTOR(int32m2)
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(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 // Test the scalable and fixed-length types can be used interchangeably
vint32m1_t __attribute__((overloadable)) vfunc(vint32m1_t op1, vint32m1_t op2); vint32m1_t __attribute__((overloadable)) vfunc(vint32m1_t op1, vint32m1_t op2);
vfloat64m1_t __attribute__((overloadable)) vfunc(vfloat64m1_t op1, vfloat64m1_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) \ #define TEST_CALL(TYPE) \
fixed_##TYPE##_t \ fixed_##TYPE##_t \
call_##TYPE##_ff(fixed_##TYPE##_t op1, fixed_##TYPE##_t op2) { \ call_##TYPE##_ff(fixed_##TYPE##_t op1, fixed_##TYPE##_t op2) { \
return vfunc(op1, op2); \ return vfunc(op1, op2); \
} \ } \
fixed_##TYPE##_t \ fixed_##TYPE##_t \
call_##TYPE##_fs(fixed_##TYPE##_t op1, v##TYPE##_t op2) { \ call_##TYPE##_fs(fixed_##TYPE##_t op1, v##TYPE##_t op2) { \
return vfunc(op1, op2); \ return vfunc(op1, op2); \
} \ } \
fixed_##TYPE##_t \ fixed_##TYPE##_t \
call_##TYPE##_sf(v##TYPE##_t op1, fixed_##TYPE##_t op2) { \ call_##TYPE##_sf(v##TYPE##_t op1, fixed_##TYPE##_t op2) { \
return vfunc(op1, op2); \ return vfunc(op1, op2); \
} }
TEST_CALL(int32m1) TEST_CALL(int32m1)
TEST_CALL(float64m1) TEST_CALL(float64m1)
TEST_CALL(int32m2)
TEST_CALL(float64m2)
TEST_CALL(int32m4)
TEST_CALL(float64m4)
TEST_CALL(int32m8)
TEST_CALL(float64m8)
// --------------------------------------------------------------------------// // --------------------------------------------------------------------------//
// Vector initialization // Vector initialization
#if __riscv_v_fixed_vlen == 256 #if __riscv_v_fixed_vlen == 256
typedef vint32m1_t int32x8 __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen))); 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 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 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}} 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 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}} 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 #endif
// --------------------------------------------------------------------------// // --------------------------------------------------------------------------//
// Vector ops // Vector ops
#define TEST_BINARY(TYPE, NAME, OP) \ #define TEST_BINARY(TYPE, NAME, OP) \
TYPE NAME##_##TYPE(TYPE op1, TYPE op2) { \ TYPE NAME##_##TYPE(TYPE op1, TYPE op2) { \
return op1 OP op2; \ return op1 OP op2; \
Show All 32 Lines#define TEST_INT_OPS(TYPE) \
TEST_BINARY(TYPE, mod, %) \ TEST_BINARY(TYPE, mod, %) \
TEST_BINARY(TYPE, and, &) \ TEST_BINARY(TYPE, and, &) \
TEST_BINARY(TYPE, or, |) \ TEST_BINARY(TYPE, or, |) \
TEST_BINARY(TYPE, xor, ^) \ TEST_BINARY(TYPE, xor, ^) \
TEST_BINARY(TYPE, shl, <<) \ TEST_BINARY(TYPE, shl, <<) \
TEST_BINARY(TYPE, shr, <<) \ TEST_BINARY(TYPE, shr, <<) \
TEST_UNARY(TYPE, not, ~) 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_int8m1_t)
TEST_INT_OPS(fixed_int16m1_t) TEST_INT_OPS(fixed_int16m1_t)
TEST_INT_OPS(fixed_int32m1_t) TEST_INT_OPS(fixed_int32m1_t)
TEST_INT_OPS(fixed_int64m1_t) TEST_INT_OPS(fixed_int64m1_t)
TEST_INT_OPS(fixed_uint8m1_t) TEST_INT_OPS(fixed_uint8m1_t)
TEST_INT_OPS(fixed_uint16m1_t) TEST_INT_OPS(fixed_uint16m1_t)
TEST_INT_OPS(fixed_uint32m1_t) TEST_INT_OPS(fixed_uint32m1_t)
TEST_INT_OPS(fixed_uint64m1_t) TEST_INT_OPS(fixed_uint64m1_t)
TEST_OPS(fixed_float32m1_t) TEST_OPS(fixed_float32m1_t)
TEST_OPS(fixed_float64m1_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)