mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
878c6281d3
The architecture doesn't really have any native v4f32 operations except v4f32->v2f64 and v2f64->v4f32 conversions, with only half of the v4f32 elements being used. Even so, using vector registers for <4 x float> and scalarising individual operations is much better than generating completely scalar code, since there's much less register pressure. It's also more efficient to do v4f32 comparisons by extending to 2 v2f64s, comparing those, then packing the result. This particularly helps with llvmpipe. Based on a patch by Richard Sandiford. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@236523 91177308-0d34-0410-b5e6-96231b3b80d8
292 lines
7.4 KiB
LLVM
292 lines
7.4 KiB
LLVM
; Test vector insertion of constants.
|
|
;
|
|
; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 | FileCheck %s
|
|
|
|
; Test v16i8 insertion into the first element.
|
|
define <16 x i8> @f1(<16 x i8> %val) {
|
|
; CHECK-LABEL: f1:
|
|
; CHECK: vleib %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 0, i32 0
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v16i8 insertion into the last element.
|
|
define <16 x i8> @f2(<16 x i8> %val) {
|
|
; CHECK-LABEL: f2:
|
|
; CHECK: vleib %v24, 100, 15
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 100, i32 15
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v16i8 insertion with the maximum signed value.
|
|
define <16 x i8> @f3(<16 x i8> %val) {
|
|
; CHECK-LABEL: f3:
|
|
; CHECK: vleib %v24, 127, 10
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 127, i32 10
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v16i8 insertion with the minimum signed value.
|
|
define <16 x i8> @f4(<16 x i8> %val) {
|
|
; CHECK-LABEL: f4:
|
|
; CHECK: vleib %v24, -128, 11
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 128, i32 11
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v16i8 insertion with the maximum unsigned value.
|
|
define <16 x i8> @f5(<16 x i8> %val) {
|
|
; CHECK-LABEL: f5:
|
|
; CHECK: vleib %v24, -1, 12
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 255, i32 12
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v16i8 insertion into a variable element.
|
|
define <16 x i8> @f6(<16 x i8> %val, i32 %index) {
|
|
; CHECK-LABEL: f6:
|
|
; CHECK-NOT: vleib
|
|
; CHECK: br %r14
|
|
%ret = insertelement <16 x i8> %val, i8 0, i32 %index
|
|
ret <16 x i8> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion into the first element.
|
|
define <8 x i16> @f7(<8 x i16> %val) {
|
|
; CHECK-LABEL: f7:
|
|
; CHECK: vleih %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 0, i32 0
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion into the last element.
|
|
define <8 x i16> @f8(<8 x i16> %val) {
|
|
; CHECK-LABEL: f8:
|
|
; CHECK: vleih %v24, 0, 7
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 0, i32 7
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion with the maximum signed value.
|
|
define <8 x i16> @f9(<8 x i16> %val) {
|
|
; CHECK-LABEL: f9:
|
|
; CHECK: vleih %v24, 32767, 4
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 32767, i32 4
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion with the minimum signed value.
|
|
define <8 x i16> @f10(<8 x i16> %val) {
|
|
; CHECK-LABEL: f10:
|
|
; CHECK: vleih %v24, -32768, 5
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 32768, i32 5
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion with the maximum unsigned value.
|
|
define <8 x i16> @f11(<8 x i16> %val) {
|
|
; CHECK-LABEL: f11:
|
|
; CHECK: vleih %v24, -1, 6
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 65535, i32 6
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v8i16 insertion into a variable element.
|
|
define <8 x i16> @f12(<8 x i16> %val, i32 %index) {
|
|
; CHECK-LABEL: f12:
|
|
; CHECK-NOT: vleih
|
|
; CHECK: br %r14
|
|
%ret = insertelement <8 x i16> %val, i16 0, i32 %index
|
|
ret <8 x i16> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion into the first element.
|
|
define <4 x i32> @f13(<4 x i32> %val) {
|
|
; CHECK-LABEL: f13:
|
|
; CHECK: vleif %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 0, i32 0
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion into the last element.
|
|
define <4 x i32> @f14(<4 x i32> %val) {
|
|
; CHECK-LABEL: f14:
|
|
; CHECK: vleif %v24, 0, 3
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 0, i32 3
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion with the maximum value allowed by VLEIF.
|
|
define <4 x i32> @f15(<4 x i32> %val) {
|
|
; CHECK-LABEL: f15:
|
|
; CHECK: vleif %v24, 32767, 1
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 32767, i32 1
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion with the next value up.
|
|
define <4 x i32> @f16(<4 x i32> %val) {
|
|
; CHECK-LABEL: f16:
|
|
; CHECK-NOT: vleif
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 32768, i32 1
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion with the minimum value allowed by VLEIF.
|
|
define <4 x i32> @f17(<4 x i32> %val) {
|
|
; CHECK-LABEL: f17:
|
|
; CHECK: vleif %v24, -32768, 2
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 -32768, i32 2
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion with the next value down.
|
|
define <4 x i32> @f18(<4 x i32> %val) {
|
|
; CHECK-LABEL: f18:
|
|
; CHECK-NOT: vleif
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 -32769, i32 2
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v4i32 insertion into a variable element.
|
|
define <4 x i32> @f19(<4 x i32> %val, i32 %index) {
|
|
; CHECK-LABEL: f19:
|
|
; CHECK-NOT: vleif
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x i32> %val, i32 0, i32 %index
|
|
ret <4 x i32> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion into the first element.
|
|
define <2 x i64> @f20(<2 x i64> %val) {
|
|
; CHECK-LABEL: f20:
|
|
; CHECK: vleig %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 0, i32 0
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion into the last element.
|
|
define <2 x i64> @f21(<2 x i64> %val) {
|
|
; CHECK-LABEL: f21:
|
|
; CHECK: vleig %v24, 0, 1
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 0, i32 1
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion with the maximum value allowed by VLEIG.
|
|
define <2 x i64> @f22(<2 x i64> %val) {
|
|
; CHECK-LABEL: f22:
|
|
; CHECK: vleig %v24, 32767, 1
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 32767, i32 1
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion with the next value up.
|
|
define <2 x i64> @f23(<2 x i64> %val) {
|
|
; CHECK-LABEL: f23:
|
|
; CHECK-NOT: vleig
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 32768, i32 1
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion with the minimum value allowed by VLEIG.
|
|
define <2 x i64> @f24(<2 x i64> %val) {
|
|
; CHECK-LABEL: f24:
|
|
; CHECK: vleig %v24, -32768, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 -32768, i32 0
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion with the next value down.
|
|
define <2 x i64> @f25(<2 x i64> %val) {
|
|
; CHECK-LABEL: f25:
|
|
; CHECK-NOT: vleig
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 -32769, i32 0
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v2i64 insertion into a variable element.
|
|
define <2 x i64> @f26(<2 x i64> %val, i32 %index) {
|
|
; CHECK-LABEL: f26:
|
|
; CHECK-NOT: vleig
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x i64> %val, i64 0, i32 %index
|
|
ret <2 x i64> %ret
|
|
}
|
|
|
|
; Test v4f32 insertion of 0 into the first element.
|
|
define <4 x float> @f27(<4 x float> %val) {
|
|
; CHECK-LABEL: f27:
|
|
; CHECK: vleif %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x float> %val, float 0.0, i32 0
|
|
ret <4 x float> %ret
|
|
}
|
|
|
|
; Test v4f32 insertion of 0 into the last element.
|
|
define <4 x float> @f28(<4 x float> %val) {
|
|
; CHECK-LABEL: f28:
|
|
; CHECK: vleif %v24, 0, 3
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x float> %val, float 0.0, i32 3
|
|
ret <4 x float> %ret
|
|
}
|
|
|
|
; Test v4f32 insertion of a nonzero value.
|
|
define <4 x float> @f29(<4 x float> %val) {
|
|
; CHECK-LABEL: f29:
|
|
; CHECK-NOT: vleif
|
|
; CHECK: br %r14
|
|
%ret = insertelement <4 x float> %val, float 1.0, i32 1
|
|
ret <4 x float> %ret
|
|
}
|
|
|
|
; Test v2f64 insertion of 0 into the first element.
|
|
define <2 x double> @f30(<2 x double> %val) {
|
|
; CHECK-LABEL: f30:
|
|
; CHECK: vleig %v24, 0, 0
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x double> %val, double 0.0, i32 0
|
|
ret <2 x double> %ret
|
|
}
|
|
|
|
; Test v2f64 insertion of 0 into the last element.
|
|
define <2 x double> @f31(<2 x double> %val) {
|
|
; CHECK-LABEL: f31:
|
|
; CHECK: vleig %v24, 0, 1
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x double> %val, double 0.0, i32 1
|
|
ret <2 x double> %ret
|
|
}
|
|
|
|
; Test v2f64 insertion of a nonzero value.
|
|
define <2 x double> @f32(<2 x double> %val) {
|
|
; CHECK-LABEL: f32:
|
|
; CHECK-NOT: vleig
|
|
; CHECK: br %r14
|
|
%ret = insertelement <2 x double> %val, double 1.0, i32 1
|
|
ret <2 x double> %ret
|
|
}
|