This is an archive of the discontinued LLVM Phabricator instance.

Differential D73786

[ARM,MVE] Fix vreinterpretq in big-endian mode.
ClosedPublic

Authored by simon_tatham on Jan 31 2020, 7:16 AM.

Details

Reviewers
dmgreen
MarkMurrayARM
miyuki
ostannard
Commits
rG961530fdc9f7: [ARM,MVE] Fix vreinterpretq in big-endian mode.
Summary

In big-endian MVE, the simple vector load/store instructions (i.e.
both contiguous and non-widening) don't all store the bytes of a
register to memory in the same order: it matters whether you did a
VSTRB.8, VSTRH.16 or VSTRW.32. Put another way, the in-register
formats of different vector types relate to each other in a different
way from the in-memory formats.

So, if you want to 'bitcast' or 'reinterpret' one vector type as
another, you have to carefully specify which you mean: did you want to
reinterpret the register format of one type as that of the other,
or the memory format?

The ACLE vreinterpretq intrinsics are specified to reinterpret the
register format. But I had implemented them as LLVM IR bitcast, which
is specified for all types as a reinterpretation of the memory format.
So a vreinterpretq intrinsic, applied to values already in registers,
would code-generate incorrectly if compiled big-endian: instead of
emitting no code, it would emit a vrev.

To fix this, I've introduced a new IR intrinsic to perform a
register-format reinterpretation: @llvm.arm.mve.vreinterpretq. It's
implemented by a trivial isel pattern that expects the input in an
MQPR register, and just returns it unchanged.

In the clang codegen, I only emit this new intrinsic where it's
actually needed: I prefer a bitcast wherever it will have the right
effect, because LLVM understands bitcasts better. So we still generate
bitcasts in little-endian mode, and even in big-endian when you're
casting between two vector types with the same lane size.

For testing, I've moved all the codegen tests of vreinterpretq out
into their own file, so that they can have a different set of RUN
lines to check both big- and little-endian.

Diff Detail

Event Timeline

simon_tatham created this revision.Jan 31 2020, 7:16 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJan 31 2020, 7:16 AM
Herald added subscribers: llvm-commits, cfe-commits, hiraditya, kristof.beyls. · View Herald Transcript
Harbormaster completed remote builds in B45453: Diff 241727.Jan 31 2020, 7:21 AM
dmgreen accepted this revision.Feb 2 2020, 7:58 AM

Big endian making things fun again.

VECTOR_REG_CAST looks useful for lowering too. LGTM

llvm/lib/Target/ARM/ARMInstrMVE.td
3958

Please add a comment, similar to this one.

This revision is now accepted and ready to land.Feb 2 2020, 7:58 AM
Closed by commit rG961530fdc9f7: [ARM,MVE] Fix vreinterpretq in big-endian mode. (authored by simon_tatham). · Explain WhyFeb 3 2020, 3:24 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
include/
clang/
Basic/
2 lines
5 lines
lib/
CodeGen/
26 lines
test/
CodeGen/
arm-mve-intrinsics/
1252 lines
1629 lines
llvm/
include/
llvm/
IR/
2 lines
lib/
Target/
ARM/
1 line
4 lines
20 lines
test/
CodeGen/
Thumb2/
61 lines

Diff 242012

clang/include/clang/Basic/arm_mve.td

Show First 20 Lines • Show All 1,057 Lines • ▼ Show 20 Linesforeach desttype = T.All in {
// _except_ that there shouldn't be one from a type to itself. // _except_ that there shouldn't be one from a type to itself.
// //
// So this foldl expression implements what you'd write in Python as // So this foldl expression implements what you'd write in Python as
// [srctype for srctype in T.All if srctype != desttype] // [srctype for srctype in T.All if srctype != desttype]
let params = !foldl([]<Type>, T.All, tlist, srctype, !listconcat(tlist, let params = !foldl([]<Type>, T.All, tlist, srctype, !listconcat(tlist,
!if(!eq(!cast<string>(desttype),!cast<string>(srctype)),[],[srctype]))) !if(!eq(!cast<string>(desttype),!cast<string>(srctype)),[],[srctype])))
in { in {
def "vreinterpretq_" # desttype: Intrinsic< def "vreinterpretq_" # desttype: Intrinsic<
VecOf<desttype>, (args Vector:$x), (bitcast $x, VecOf<desttype>)>; VecOf<desttype>, (args Vector:$x), (vreinterpret $x, VecOf<desttype>)>;
} }
} }
let params = T.All in { let params = T.All in {
let pnt = PNT_None in { let pnt = PNT_None in {
def vcreateq: Intrinsic<Vector, (args u64:$a, u64:$b), def vcreateq: Intrinsic<Vector, (args u64:$a, u64:$b),
(bitcast (ielt_const (ielt_const (undef VecOf<u64>), $a, 0), (bitcast (ielt_const (ielt_const (undef VecOf<u64>), $a, 0),
$b, 1), Vector)>; $b, 1), Vector)>;
Show All 26 Lines

clang/include/clang/Basic/arm_mve_defs.td

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesclass IRFunction<string func> : IRBuilderBase {
// Some other function that doesn't use the IRBuilder at all. // Some other function that doesn't use the IRBuilder at all.
let prefix = func # "("; let prefix = func # "(";
} }
class CGHelperFn<string func> : IRBuilderBase { class CGHelperFn<string func> : IRBuilderBase {
// A helper function defined in CGBuiltin.cpp, which takes the IRBuilder as // A helper function defined in CGBuiltin.cpp, which takes the IRBuilder as
// an argument. // an argument.
let prefix = func # "(Builder, "; let prefix = func # "(Builder, ";
} }
class CGFHelperFn<string func> : IRBuilderBase {
// Like CGHelperFn, but also takes the CodeGenFunction itself.
let prefix = func # "(Builder, this, ";
}
def add: IRBuilder<"CreateAdd">; def add: IRBuilder<"CreateAdd">;
def mul: IRBuilder<"CreateMul">; def mul: IRBuilder<"CreateMul">;
def not: IRBuilder<"CreateNot">; def not: IRBuilder<"CreateNot">;
def or: IRBuilder<"CreateOr">; def or: IRBuilder<"CreateOr">;
def and: IRBuilder<"CreateAnd">; def and: IRBuilder<"CreateAnd">;
def xor: IRBuilder<"CreateXor">; def xor: IRBuilder<"CreateXor">;
def sub: IRBuilder<"CreateSub">; def sub: IRBuilder<"CreateSub">;
def shl: IRBuilder<"CreateShl">; def shl: IRBuilder<"CreateShl">;
Show All 16 Lines
} }
def ielt_const: IRBuilder<"CreateInsertElement"> { def ielt_const: IRBuilder<"CreateInsertElement"> {
let special_params = [IRBuilderIntParam<2, "uint64_t">]; let special_params = [IRBuilderIntParam<2, "uint64_t">];
} }
def ielt_var: IRBuilder<"CreateInsertElement">; def ielt_var: IRBuilder<"CreateInsertElement">;
def xelt_var: IRBuilder<"CreateExtractElement">; def xelt_var: IRBuilder<"CreateExtractElement">;
def trunc: IRBuilder<"CreateTrunc">; def trunc: IRBuilder<"CreateTrunc">;
def bitcast: IRBuilder<"CreateBitCast">; def bitcast: IRBuilder<"CreateBitCast">;
def vreinterpret: CGFHelperFn<"ARMMVEVectorReinterpret">;
def extend: CGHelperFn<"SignOrZeroExtend"> { def extend: CGHelperFn<"SignOrZeroExtend"> {
let special_params = [IRBuilderIntParam<2, "bool">]; let special_params = [IRBuilderIntParam<2, "bool">];
} }
def zeroinit: IRFunction<"llvm::Constant::getNullValue">; def zeroinit: IRFunction<"llvm::Constant::getNullValue">;
def undef: IRFunction<"UndefValue::get">; def undef: IRFunction<"UndefValue::get">;
def icmp_eq: IRBuilder<"CreateICmpEQ">; def icmp_eq: IRBuilder<"CreateICmpEQ">;
def icmp_ne: IRBuilder<"CreateICmpNE">; def icmp_ne: IRBuilder<"CreateICmpNE">;
def icmp_ugt: IRBuilder<"CreateICmpUGT">; def icmp_ugt: IRBuilder<"CreateICmpUGT">;
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

clang/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,013 Lines • ▼ Show 20 Lines
static llvm::Value *ARMMVEVectorSplat(CGBuilderTy &Builder, llvm::Value *V) { static llvm::Value *ARMMVEVectorSplat(CGBuilderTy &Builder, llvm::Value *V) {
// MVE-specific helper function for a vector splat, which infers the element // MVE-specific helper function for a vector splat, which infers the element
// count of the output vector by knowing that MVE vectors are all 128 bits // count of the output vector by knowing that MVE vectors are all 128 bits
// wide. // wide.
unsigned Elements = 128 / V->getType()->getPrimitiveSizeInBits(); unsigned Elements = 128 / V->getType()->getPrimitiveSizeInBits();
return Builder.CreateVectorSplat(Elements, V); return Builder.CreateVectorSplat(Elements, V);
} }
static llvm::Value *ARMMVEVectorReinterpret(CGBuilderTy &Builder,
CodeGenFunction *CGF,
llvm::Value *V,
llvm::Type *DestType) {
// Convert one MVE vector type into another by reinterpreting its in-register
// format.
//
// Little-endian, this is identical to a bitcast (which reinterprets the
// memory format). But big-endian, they're not necessarily the same, because
// the register and memory formats map to each other differently depending on
// the lane size.
//
// We generate a bitcast whenever we can (if we're little-endian, or if the
// lane sizes are the same anyway). Otherwise we fall back to an IR intrinsic
// that performs the different kind of reinterpretation.
if (CGF->getTarget().isBigEndian() &&
V->getType()->getScalarSizeInBits() != DestType->getScalarSizeInBits()) {
return Builder.CreateCall(
CGF->CGM.getIntrinsic(Intrinsic::arm_mve_vreinterpretq,
{DestType, V->getType()}),
V);
} else {
return Builder.CreateBitCast(V, DestType);
}
}
Value *CodeGenFunction::EmitARMMVEBuiltinExpr(unsigned BuiltinID, Value *CodeGenFunction::EmitARMMVEBuiltinExpr(unsigned BuiltinID,
const CallExpr *E, const CallExpr *E,
ReturnValueSlot ReturnValue, ReturnValueSlot ReturnValue,
llvm::Triple::ArchType Arch) { llvm::Triple::ArchType Arch) {
enum class CustomCodeGen { VLD24, VST24 } CustomCodeGenType; enum class CustomCodeGen { VLD24, VST24 } CustomCodeGenType;
Intrinsic::ID IRIntr; Intrinsic::ID IRIntr;
unsigned NumVectors; unsigned NumVectors;
▲ Show 20 Lines • Show All 8,054 Lines • Show Last 20 Lines

clang/test/CodeGen/arm-mve-intrinsics/admin.c

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
// CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to <16 x i8> // CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP2]] // CHECK-NEXT: ret <16 x i8> [[TMP2]]
// //
uint8x16_t test_vcreateq_u8(uint64_t a, uint64_t b) uint8x16_t test_vcreateq_u8(uint64_t a, uint64_t b)
{ {
return vcreateq_u8(a, b); return vcreateq_u8(a, b);
} }
// CHECK-LABEL: @test_vreinterpretq_f16_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f16_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x half>
// CHECK-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_f32_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <8 x i16> [[A:%.*]]
//
int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s16_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <4 x i32> [[A:%.*]]
//
int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s32_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <2 x i64> [[A:%.*]]
//
int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s64_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_s8_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <16 x i8> [[A:%.*]]
//
int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <8 x i16> [[A:%.*]]
//
uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u16_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <4 x i32> [[A:%.*]]
//
uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u32_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <2 x i64> [[A:%.*]]
//
uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u64_u8(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_f16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_f16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_f32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_f32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_s16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_s32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_s64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_s8(
// CHECK-NEXT: entry:
// CHECK-NEXT: ret <16 x i8> [[A:%.*]]
//
uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s8(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_u16(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u16(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_u32(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u32(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vreinterpretq_u8_u64(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// CHECK-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u64(a);
#endif /* POLYMORPHIC */
}
// CHECK-LABEL: @test_vuninitializedq_polymorphic_f16( // CHECK-LABEL: @test_vuninitializedq_polymorphic_f16(
// CHECK-NEXT: entry: // CHECK-NEXT: entry:
// CHECK-NEXT: ret <8 x half> undef // CHECK-NEXT: ret <8 x half> undef
// //
float16x8_t test_vuninitializedq_polymorphic_f16(float16x8_t (*funcptr)(void)) float16x8_t test_vuninitializedq_polymorphic_f16(float16x8_t (*funcptr)(void))
{ {
return vuninitializedq(funcptr()); return vuninitializedq(funcptr());
} }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

clang/test/CodeGen/arm-mve-intrinsics/reinterpret.c

  • This file was added.
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -S -emit-llvm -o - %s | opt -S -mem2reg -sroa -early-cse | FileCheck %s --check-prefix=BOTH --check-prefix=LE
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -DPOLYMORPHIC -S -emit-llvm -o - %s | opt -S -mem2reg -sroa -early-cse | FileCheck %s --check-prefix=BOTH --check-prefix=LE
// RUN: %clang_cc1 -triple thumbebv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -S -emit-llvm -o - %s | opt -S -mem2reg -sroa -early-cse | FileCheck %s --check-prefix=BOTH --check-prefix=BE
// RUN: %clang_cc1 -triple thumbebv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -DPOLYMORPHIC -S -emit-llvm -o - %s | opt -S -mem2reg -sroa -early-cse | FileCheck %s --check-prefix=BOTH --check-prefix=BE
#include <arm_mve.h>
// LE-LABEL: @test_vreinterpretq_f16_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_f32(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_f16_s16(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <8 x half>
// BOTH-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_s8(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_f16_u16(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <8 x half>
// BOTH-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f16_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x half>
// LE-NEXT: ret <8 x half> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f16_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x half> @llvm.arm.mve.vreinterpretq.v8f16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x half> [[TMP0]]
//
float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f16(a);
#else /* POLYMORPHIC */
return vreinterpretq_f16_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_f32_s32(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <4 x float>
// BOTH-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_f32_u32(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <4 x float>
// BOTH-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_f32_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x float>
// LE-NEXT: ret <4 x float> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_f32_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x float> @llvm.arm.mve.vreinterpretq.v4f32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x float> [[TMP0]]
//
float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_f32(a);
#else /* POLYMORPHIC */
return vreinterpretq_f32_u8(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s16_f16(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <8 x i16>
// BOTH-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_s8(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s16_u16(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <8 x i16> [[A:%.*]]
//
int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s16_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s16_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s16(a);
#else /* POLYMORPHIC */
return vreinterpretq_s16_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_f16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s32_f32(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <4 x i32>
// BOTH-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s32_u32(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <4 x i32> [[A:%.*]]
//
int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s32_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s32_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s32(a);
#else /* POLYMORPHIC */
return vreinterpretq_s32_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u32(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s64_u64(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <2 x i64> [[A:%.*]]
//
int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s64_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s64_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s64(a);
#else /* POLYMORPHIC */
return vreinterpretq_s64_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_s8_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_s8_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u64(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_s8_u8(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <16 x i8> [[A:%.*]]
//
int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_s8(a);
#else /* POLYMORPHIC */
return vreinterpretq_s8_u8(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u16_f16(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <8 x i16>
// BOTH-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_f32(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u16_s16(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <8 x i16> [[A:%.*]]
//
uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u16_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <8 x i16>
// LE-NEXT: ret <8 x i16> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u16_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <8 x i16> [[TMP0]]
//
uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u16(a);
#else /* POLYMORPHIC */
return vreinterpretq_u16_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_f16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u32_f32(
// BOTH-NEXT: entry:
// BOTH-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <4 x i32>
// BOTH-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s16(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u32_s32(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <4 x i32> [[A:%.*]]
//
uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u32_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <4 x i32>
// LE-NEXT: ret <4 x i32> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u32_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vreinterpretq.v4i32.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <4 x i32> [[TMP0]]
//
uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u32(a);
#else /* POLYMORPHIC */
return vreinterpretq_u32_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s32(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u64_s64(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <2 x i64> [[A:%.*]]
//
uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s64(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_s8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_s8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u64_u8(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <16 x i8> [[A:%.*]] to <2 x i64>
// LE-NEXT: ret <2 x i64> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u64_u8(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vreinterpretq.v2i64.v16i8(<16 x i8> [[A:%.*]])
// BE-NEXT: ret <2 x i64> [[TMP0]]
//
uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u64(a);
#else /* POLYMORPHIC */
return vreinterpretq_u64_u8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_f16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x half> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_f16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8f16(<8 x half> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_f16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_f32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x float> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_f32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4f32(<4 x float> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_f32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_s16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_s16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_s32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_s32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_s64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_s64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s64(a);
#endif /* POLYMORPHIC */
}
// BOTH-LABEL: @test_vreinterpretq_u8_s8(
// BOTH-NEXT: entry:
// BOTH-NEXT: ret <16 x i8> [[A:%.*]]
//
uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_s8(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_u16(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <8 x i16> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_u16(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v8i16(<8 x i16> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u16(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_u32(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_u32(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v4i32(<4 x i32> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u32(a);
#endif /* POLYMORPHIC */
}
// LE-LABEL: @test_vreinterpretq_u8_u64(
// LE-NEXT: entry:
// LE-NEXT: [[TMP0:%.*]] = bitcast <2 x i64> [[A:%.*]] to <16 x i8>
// LE-NEXT: ret <16 x i8> [[TMP0]]
//
// BE-LABEL: @test_vreinterpretq_u8_u64(
// BE-NEXT: entry:
// BE-NEXT: [[TMP0:%.*]] = call <16 x i8> @llvm.arm.mve.vreinterpretq.v16i8.v2i64(<2 x i64> [[A:%.*]])
// BE-NEXT: ret <16 x i8> [[TMP0]]
//
uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a)
{
#ifdef POLYMORPHIC
return vreinterpretq_u8(a);
#else /* POLYMORPHIC */
return vreinterpretq_u8_u64(a);
#endif /* POLYMORPHIC */
}

llvm/include/llvm/IR/IntrinsicsARM.td

Show First 20 Lines • Show All 789 Lines • ▼ Show 20 Lines
def int_arm_gnu_eabi_mcount : Intrinsic<[], def int_arm_gnu_eabi_mcount : Intrinsic<[],
[], [],
[IntrReadMem, IntrWriteMem]>; [IntrReadMem, IntrWriteMem]>;
def int_arm_mve_pred_i2v : Intrinsic< def int_arm_mve_pred_i2v : Intrinsic<
[llvm_anyvector_ty], [llvm_i32_ty], [IntrNoMem]>; [llvm_anyvector_ty], [llvm_i32_ty], [IntrNoMem]>;
def int_arm_mve_pred_v2i : Intrinsic< def int_arm_mve_pred_v2i : Intrinsic<
[llvm_i32_ty], [llvm_anyvector_ty], [IntrNoMem]>; [llvm_i32_ty], [llvm_anyvector_ty], [IntrNoMem]>;
def int_arm_mve_vreinterpretq : Intrinsic<
[llvm_anyvector_ty], [llvm_anyvector_ty], [IntrNoMem]>;
multiclass IntrinsicSignSuffix<list<LLVMType> rets, list<LLVMType> params = [], multiclass IntrinsicSignSuffix<list<LLVMType> rets, list<LLVMType> params = [],
list<IntrinsicProperty> props = [], list<IntrinsicProperty> props = [],
string name = "", string name = "",
list<SDNodeProperty> sdprops = []> { list<SDNodeProperty> sdprops = []> {
def _s: Intrinsic<rets, params, props, name, sdprops>; def _s: Intrinsic<rets, params, props, name, sdprops>;
def _u: Intrinsic<rets, params, props, name, sdprops>; def _u: Intrinsic<rets, params, props, name, sdprops>;
} }
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMISelLowering.h

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines enum NodeType : unsigned {
WIN__CHKSTK, // Windows' __chkstk call to do stack probing. WIN__CHKSTK, // Windows' __chkstk call to do stack probing.
WIN__DBZCHK, // Windows' divide by zero check WIN__DBZCHK, // Windows' divide by zero check
WLS, // Low-overhead loops, While Loop Start WLS, // Low-overhead loops, While Loop Start
LOOP_DEC, // Really a part of LE, performs the sub LOOP_DEC, // Really a part of LE, performs the sub
LE, // Low-overhead loops, Loop End LE, // Low-overhead loops, Loop End
PREDICATE_CAST, // Predicate cast for MVE i1 types PREDICATE_CAST, // Predicate cast for MVE i1 types
VECTOR_REG_CAST, // Reinterpret the current contents of a vector register
VCMP, // Vector compare. VCMP, // Vector compare.
VCMPZ, // Vector compare to zero. VCMPZ, // Vector compare to zero.
VTST, // Vector test bits. VTST, // Vector test bits.
// Vector shift by vector // Vector shift by vector
VSHLs, // ...left/right by signed VSHLs, // ...left/right by signed
VSHLu, // ...left/right by unsigned VSHLu, // ...left/right by unsigned
▲ Show 20 Lines • Show All 722 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,599 Lines • ▼ Show 20 Linesconst char *ARMTargetLowering::getTargetNodeName(unsigned Opcode) const {
case ARMISD::LDRD: return "ARMISD::LDRD"; case ARMISD::LDRD: return "ARMISD::LDRD";
case ARMISD::STRD: return "ARMISD::STRD"; case ARMISD::STRD: return "ARMISD::STRD";
case ARMISD::WIN__CHKSTK: return "ARMISD::WIN__CHKSTK"; case ARMISD::WIN__CHKSTK: return "ARMISD::WIN__CHKSTK";
case ARMISD::WIN__DBZCHK: return "ARMISD::WIN__DBZCHK"; case ARMISD::WIN__DBZCHK: return "ARMISD::WIN__DBZCHK";
case ARMISD::PREDICATE_CAST: return "ARMISD::PREDICATE_CAST"; case ARMISD::PREDICATE_CAST: return "ARMISD::PREDICATE_CAST";
case ARMISD::VECTOR_REG_CAST: return "ARMISD::VECTOR_REG_CAST";
case ARMISD::VCMP: return "ARMISD::VCMP"; case ARMISD::VCMP: return "ARMISD::VCMP";
case ARMISD::VCMPZ: return "ARMISD::VCMPZ"; case ARMISD::VCMPZ: return "ARMISD::VCMPZ";
case ARMISD::VTST: return "ARMISD::VTST"; case ARMISD::VTST: return "ARMISD::VTST";
case ARMISD::VSHLs: return "ARMISD::VSHLs"; case ARMISD::VSHLs: return "ARMISD::VSHLs";
case ARMISD::VSHLu: return "ARMISD::VSHLu"; case ARMISD::VSHLu: return "ARMISD::VSHLu";
case ARMISD::VSHLIMM: return "ARMISD::VSHLIMM"; case ARMISD::VSHLIMM: return "ARMISD::VSHLIMM";
case ARMISD::VSHRsIMM: return "ARMISD::VSHRsIMM"; case ARMISD::VSHRsIMM: return "ARMISD::VSHRsIMM";
▲ Show 20 Lines • Show All 2,156 Lines • ▼ Show 20 Lines return DAG.getNode(ARMISD::VTBL1, SDLoc(Op), Op.getValueType(),
Op.getOperand(1), Op.getOperand(2)); Op.getOperand(1), Op.getOperand(2));
case Intrinsic::arm_neon_vtbl2: case Intrinsic::arm_neon_vtbl2:
return DAG.getNode(ARMISD::VTBL2, SDLoc(Op), Op.getValueType(), return DAG.getNode(ARMISD::VTBL2, SDLoc(Op), Op.getValueType(),
Op.getOperand(1), Op.getOperand(2), Op.getOperand(3)); Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
case Intrinsic::arm_mve_pred_i2v: case Intrinsic::arm_mve_pred_i2v:
case Intrinsic::arm_mve_pred_v2i: case Intrinsic::arm_mve_pred_v2i:
return DAG.getNode(ARMISD::PREDICATE_CAST, SDLoc(Op), Op.getValueType(), return DAG.getNode(ARMISD::PREDICATE_CAST, SDLoc(Op), Op.getValueType(),
Op.getOperand(1)); Op.getOperand(1));
case Intrinsic::arm_mve_vreinterpretq:
return DAG.getNode(ARMISD::VECTOR_REG_CAST, SDLoc(Op), Op.getValueType(),
Op.getOperand(1));
} }
} }
static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG, static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG,
const ARMSubtarget *Subtarget) { const ARMSubtarget *Subtarget) {
SDLoc dl(Op); SDLoc dl(Op);
ConstantSDNode *SSIDNode = cast<ConstantSDNode>(Op.getOperand(2)); ConstantSDNode *SSIDNode = cast<ConstantSDNode>(Op.getOperand(2));
auto SSID = static_cast<SyncScope::ID>(SSIDNode->getZExtValue()); auto SSID = static_cast<SyncScope::ID>(SSIDNode->getZExtValue());
▲ Show 20 Lines • Show All 13,832 Lines • Show Last 20 Lines

llvm/lib/Target/ARM/ARMInstrMVE.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,949 Lines • ▼ Show 20 Lines
} }
let Predicates = [HasMVEInt] in { let Predicates = [HasMVEInt] in {
defm POR : two_predops<or, t2ORRrr>; defm POR : two_predops<or, t2ORRrr>;
defm PAND : two_predops<and, t2ANDrr>; defm PAND : two_predops<and, t2ANDrr>;
defm PEOR : two_predops<xor, t2EORrr>; defm PEOR : two_predops<xor, t2EORrr>;
} }
// Occasionally we need to cast between a i32 and a boolean vector, for // Occasionally we need to cast between a i32 and a boolean vector, for
dmgreenUnsubmitted
Not Done
ReplyInline Actions

Please add a comment, similar to this one.

dmgreen: Please add a comment, similar to this one.
// example when moving between rGPR and VPR.P0 as part of predicate vector // example when moving between rGPR and VPR.P0 as part of predicate vector
// shuffles. We also sometimes need to cast between different predicate // shuffles. We also sometimes need to cast between different predicate
// vector types (v4i1<>v8i1, etc.) also as part of lowering vector shuffles. // vector types (v4i1<>v8i1, etc.) also as part of lowering vector shuffles.
def predicate_cast : SDNode<"ARMISD::PREDICATE_CAST", SDTUnaryOp>; def predicate_cast : SDNode<"ARMISD::PREDICATE_CAST", SDTUnaryOp>;
// 'vector_reg_cast' is an operation that reinterprets the contents of an MVE
// vector register as a different vector type, without changing the contents of
// the register. It differs from 'bitconvert' in that bitconvert reinterprets
// the _memory_ storage format of the vector, whereas vector_reg_cast
// reinterprets the _register_ format - and in big-endian, the memory and
// register formats are different, so they are different operations.
//
// For example, 'vector_reg_cast' between v8i16 and v16i8 will map the LSB of
// the zeroth i16 lane to the zeroth i8 lane, regardless of system endianness,
// whereas 'bitconvert' will map it to the high byte in big-endian mode,
// because that's what VSTRH.16 followed by VLDRB.8 would do. So the bitconvert
// would have to emit a VREV16.8 instruction, whereas the vector_reg_cast emits
// no code at all if the vector is already in a register.
def vector_reg_cast : SDNode<"ARMISD::VECTOR_REG_CAST", SDTUnaryOp>;
let Predicates = [HasMVEInt] in { let Predicates = [HasMVEInt] in {
foreach VT = [ v4i1, v8i1, v16i1 ] in { foreach VT = [ v4i1, v8i1, v16i1 ] in {
def : Pat<(i32 (predicate_cast (VT VCCR:$src))), def : Pat<(i32 (predicate_cast (VT VCCR:$src))),
(i32 (COPY_TO_REGCLASS (VT VCCR:$src), VCCR))>; (i32 (COPY_TO_REGCLASS (VT VCCR:$src), VCCR))>;
def : Pat<(VT (predicate_cast (i32 VCCR:$src))), def : Pat<(VT (predicate_cast (i32 VCCR:$src))),
(VT (COPY_TO_REGCLASS (i32 VCCR:$src), VCCR))>; (VT (COPY_TO_REGCLASS (i32 VCCR:$src), VCCR))>;
foreach VT2 = [ v4i1, v8i1, v16i1 ] in foreach VT2 = [ v4i1, v8i1, v16i1 ] in
def : Pat<(VT (predicate_cast (VT2 VCCR:$src))), def : Pat<(VT (predicate_cast (VT2 VCCR:$src))),
(VT (COPY_TO_REGCLASS (VT2 VCCR:$src), VCCR))>; (VT (COPY_TO_REGCLASS (VT2 VCCR:$src), VCCR))>;
} }
foreach VT = [ v16i8, v8i16, v8f16, v4i32, v4f32, v2i64, v2f64 ] in
foreach VT2 = [ v16i8, v8i16, v8f16, v4i32, v4f32, v2i64, v2f64 ] in
def : Pat<(VT (vector_reg_cast (VT2 MQPR:$src))), (VT MQPR:$src)>;
} }
// end of MVE compares // end of MVE compares
// start of MVE_qDest_qSrc // start of MVE_qDest_qSrc
class MVE_qDest_qSrc<string iname, string suffix, dag oops, dag iops, class MVE_qDest_qSrc<string iname, string suffix, dag oops, dag iops,
string ops, vpred_ops vpred, string cstr, string ops, vpred_ops vpred, string cstr,
▲ Show 20 Lines • Show All 2,472 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-be.ll

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
entry: entry:
%add.ptr = getelementptr inbounds i32, i32* %data, i32 8 %add.ptr = getelementptr inbounds i32, i32* %data, i32 8
%0 = bitcast i32* %add.ptr to <4 x i32>* %0 = bitcast i32* %add.ptr to <4 x i32>*
%1 = load <4 x i32>, <4 x i32>* %0, align 4 %1 = load <4 x i32>, <4 x i32>* %0, align 4
%2 = add <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1> %2 = add <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1>
%3 = tail call <4 x i32> asm sideeffect " VMULLB.s32 $0, $1, $1", "=&w,w"(<4 x i32> %2) #2 %3 = tail call <4 x i32> asm sideeffect " VMULLB.s32 $0, $1, $1", "=&w,w"(<4 x i32> %2) #2
ret <4 x i32> %3 ret <4 x i32> %3
} }
; Test case demonstrating that 'bitcast' reinterprets the memory format of a
; vector, as if stored and then loaded. So if it has to go between two
; operations treating a register as having different lane sizes, then in
; big-endian mode, it has to emit a vrev32.16, which is equivalent to the
; effect that vstrw.32 followed by vldrh.16 would have.
define arm_aapcs_vfpcc void @test_bitcast(<4 x i32>* readonly %in, <8 x i16>* %out) {
; CHECK-LE-LABEL: test_bitcast:
; CHECK-LE: @ %bb.0: @ %entry
; CHECK-LE-NEXT: vldrw.u32 q0, [r0]
; CHECK-LE-NEXT: vmul.i32 q0, q0, q0
; CHECK-LE-NEXT: vmul.i16 q0, q0, q0
; CHECK-LE-NEXT: vstrw.32 q0, [r1]
; CHECK-LE-NEXT: bx lr
;
; CHECK-BE-LABEL: test_bitcast:
; CHECK-BE: @ %bb.0: @ %entry
; CHECK-BE-NEXT: vldrw.u32 q0, [r0]
; CHECK-BE-NEXT: vmul.i32 q0, q0, q0
; CHECK-BE-NEXT: vrev32.16 q0, q0
; CHECK-BE-NEXT: vmul.i16 q0, q0, q0
; CHECK-BE-NEXT: vstrh.16 q0, [r1]
; CHECK-BE-NEXT: bx lr
entry:
%vin = load <4 x i32>, <4 x i32>* %in, align 8
%vdbl = mul <4 x i32> %vin, %vin
%cast = bitcast <4 x i32> %vdbl to <8 x i16>
%cdbl = mul <8 x i16> %cast, %cast
store <8 x i16> %cdbl, <8 x i16>* %out, align 8
ret void
}
; Similar test case but using the arm.mve.vreinterpretq intrinsic instead,
; which is defined to reinterpret the in-register format, so it generates no
; instruction in either endianness.
define arm_aapcs_vfpcc void @test_vreinterpretq(<4 x i32>* readonly %in, <8 x i16>* %out) {
; CHECK-LE-LABEL: test_vreinterpretq:
; CHECK-LE: @ %bb.0: @ %entry
; CHECK-LE-NEXT: vldrw.u32 q0, [r0]
; CHECK-LE-NEXT: vmul.i32 q0, q0, q0
; CHECK-LE-NEXT: vmul.i16 q0, q0, q0
; CHECK-LE-NEXT: vstrw.32 q0, [r1]
; CHECK-LE-NEXT: bx lr
;
; CHECK-BE-LABEL: test_vreinterpretq:
; CHECK-BE: @ %bb.0: @ %entry
; CHECK-BE-NEXT: vldrw.u32 q0, [r0]
; CHECK-BE-NEXT: vmul.i32 q0, q0, q0
; CHECK-BE-NEXT: vmul.i16 q0, q0, q0
; CHECK-BE-NEXT: vstrh.16 q0, [r1]
; CHECK-BE-NEXT: bx lr
entry:
%vin = load <4 x i32>, <4 x i32>* %in, align 8
%vdbl = mul <4 x i32> %vin, %vin
%cast = call <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32> %vdbl)
%cdbl = mul <8 x i16> %cast, %cast
store <8 x i16> %cdbl, <8 x i16>* %out, align 8
ret void
}
declare <8 x i16> @llvm.arm.mve.vreinterpretq.v8i16.v4i32(<4 x i32>)