mirror of
https://github.com/RPCSX/llvm.git
synced 2024-11-28 14:10:41 +00:00
045b2171c4
This patch allows VSX swap optimization to succeed more frequently. Specifically, it is concerned with common code sequences that occur when copying a scalar floating-point value to a vector register. This patch currently handles cases where the floating-point value is already in a register, but does not yet handle loads (such as via an LXSDX scalar floating-point VSX load). That will be dealt with later. A typical case is when a scalar value comes in as a floating-point parameter. The value is copied into a virtual VSFRC register, and then a sequence of SUBREG_TO_REG and/or COPY operations will convert it to a full vector register of the class required by the context. If this vector register is then used as part of a lane-permuted computation, the original scalar value will be in the wrong lane. We can fix this by adding a swap operation following any widening SUBREG_TO_REG operation. Additional COPY operations may be needed around the swap operation in order to keep register assignment happy, but these are pro forma operations that will be removed by coalescing. If a scalar value is otherwise directly referenced in a computation (such as by one of the many XS* vector-scalar operations), we currently disable swap optimization. These operations are lane-sensitive by definition. A MentionsPartialVR flag is added for use in each swap table entry that mentions a scalar floating-point register without having special handling defined. A common idiom for PPC64LE is to convert a double-precision scalar to a vector by performing a splat operation. This ensures that the value can be referenced as V[0], as it would be for big endian, whereas just converting the scalar to a vector with a SUBREG_TO_REG operation leaves this value only in V[1]. A doubleword splat operation is one form of an XXPERMDI instruction, which takes one doubleword from a first operand and another doubleword from a second operand, with a two-bit selector operand indicating which doublewords are chosen. In the general case, an XXPERMDI can be permitted in a lane-swapped region provided that it is properly transformed to select the corresponding swapped values. This transformation is to reverse the order of the two input operands, and to reverse and complement the bits of the selector operand (derivation left as an exercise to the reader ;). A new test case that exercises the scalar-to-vector and generalized XXPERMDI transformations is added as CodeGen/PowerPC/swaps-le-5.ll. The patch also requires a change to CodeGen/PowerPC/swaps-le-3.ll to use CHECK-DAG instead of CHECK for two independent instructions that now appear in reverse order. There are two small unrelated changes that are added with this patch. First, the XXSLDWI instruction was incorrectly omitted from the list of lane-sensitive instructions; this is now fixed. Second, I observed that the same webs were being rejected over and over again for different reasons. Since it's sufficient to reject a web only once, I added a check for this to speed up the compilation time slightly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@242081 91177308-0d34-0410-b5e6-96231b3b80d8
71 lines
2.0 KiB
LLVM
71 lines
2.0 KiB
LLVM
; RUN: llc -mcpu=pwr8 -mtriple=powerpc64le-unknown-linux-gnu -O3 < %s | FileCheck %s
|
|
|
|
; These tests verify that VSX swap optimization works for various
|
|
; manipulations of <2 x double> vectors.
|
|
|
|
@x = global <2 x double> <double 9.970000e+01, double -1.032220e+02>, align 16
|
|
@z = global <2 x double> <double 2.332000e+01, double 3.111111e+01>, align 16
|
|
|
|
define void @bar0(double %y) {
|
|
entry:
|
|
%0 = load <2 x double>, <2 x double>* @x, align 16
|
|
%vecins = insertelement <2 x double> %0, double %y, i32 0
|
|
store <2 x double> %vecins, <2 x double>* @z, align 16
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: @bar0
|
|
; CHECK-DAG: xxswapd {{[0-9]+}}, 1
|
|
; CHECK-DAG: lxvd2x [[REG1:[0-9]+]]
|
|
; CHECK-DAG: xxspltd [[REG2:[0-9]+]]
|
|
; CHECK: xxpermdi [[REG3:[0-9]+]], [[REG2]], [[REG1]], 1
|
|
; CHECK: stxvd2x [[REG3]]
|
|
|
|
define void @bar1(double %y) {
|
|
entry:
|
|
%0 = load <2 x double>, <2 x double>* @x, align 16
|
|
%vecins = insertelement <2 x double> %0, double %y, i32 1
|
|
store <2 x double> %vecins, <2 x double>* @z, align 16
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: @bar1
|
|
; CHECK-DAG: xxswapd {{[0-9]+}}, 1
|
|
; CHECK-DAG: lxvd2x [[REG1:[0-9]+]]
|
|
; CHECK-DAG: xxspltd [[REG2:[0-9]+]]
|
|
; CHECK: xxmrghd [[REG3:[0-9]+]], [[REG1]], [[REG2]]
|
|
; CHECK: stxvd2x [[REG3]]
|
|
|
|
define void @baz0() {
|
|
entry:
|
|
%0 = load <2 x double>, <2 x double>* @z, align 16
|
|
%1 = load <2 x double>, <2 x double>* @x, align 16
|
|
%vecins = shufflevector <2 x double> %0, <2 x double> %1, <2 x i32> <i32 0, i32 2>
|
|
store <2 x double> %vecins, <2 x double>* @z, align 16
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: @baz0
|
|
; CHECK: lxvd2x
|
|
; CHECK: lxvd2x
|
|
; CHECK: xxmrghd
|
|
; CHECK: stxvd2x
|
|
; CHECK-NOT: xxswapd
|
|
|
|
define void @baz1() {
|
|
entry:
|
|
%0 = load <2 x double>, <2 x double>* @z, align 16
|
|
%1 = load <2 x double>, <2 x double>* @x, align 16
|
|
%vecins = shufflevector <2 x double> %0, <2 x double> %1, <2 x i32> <i32 3, i32 1>
|
|
store <2 x double> %vecins, <2 x double>* @z, align 16
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: @baz1
|
|
; CHECK: lxvd2x
|
|
; CHECK: lxvd2x
|
|
; CHECK: xxmrgld
|
|
; CHECK: stxvd2x
|
|
; CHECK-NOT: xxswapd
|
|
|