[llvm] r207485 - [ARM64]Fix a bug when lowering shuffle vector to an EXT instruction.
Hao Liu
Hao.Liu at arm.com
Mon Apr 28 18:50:36 PDT 2014
Author: haoliu
Date: Mon Apr 28 20:50:36 2014
New Revision: 207485
URL: http://llvm.org/viewvc/llvm-project?rev=207485&view=rev
Log:
[ARM64]Fix a bug when lowering shuffle vector to an EXT instruction.
E.g. Mask like <-1, -1, 1, ...> will generate incorrect EXT index.
Modified:
llvm/trunk/lib/Target/ARM64/ARM64ISelLowering.cpp
llvm/trunk/test/CodeGen/ARM64/ext.ll
Modified: llvm/trunk/lib/Target/ARM64/ARM64ISelLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM64/ARM64ISelLowering.cpp?rev=207485&r1=207484&r2=207485&view=diff
==============================================================================
--- llvm/trunk/lib/Target/ARM64/ARM64ISelLowering.cpp (original)
+++ llvm/trunk/lib/Target/ARM64/ARM64ISelLowering.cpp Mon Apr 28 20:50:36 2014
@@ -3981,39 +3981,34 @@ static bool isSingletonEXTMask(ArrayRef<
// vector sources of the shuffle are different.
static bool isEXTMask(ArrayRef<int> M, EVT VT, bool &ReverseEXT,
unsigned &Imm) {
- unsigned NumElts = VT.getVectorNumElements();
- ReverseEXT = false;
+ // Look for the first non-undef element.
+ const int *FirstRealElt = std::find_if(M.begin(), M.end(),
+ [](int Elt) {return Elt >= 0;});
- // Look for the first non-undef choice and count backwards from
- // that. E.g. <-1, -1, 3, ...> means that an EXT must start at 3 - 2 = 1. This
- // guarantees that at least one index is correct.
- const int *FirstRealElt =
- std::find_if(M.begin(), M.end(), [](int Elt) { return Elt >= 0; });
- assert(FirstRealElt != M.end() && "Completely UNDEF shuffle? Why bother?");
- Imm = *FirstRealElt - (FirstRealElt - M.begin());
+ // Benefit form APInt to handle overflow when calculating expected element.
+ unsigned NumElts = VT.getVectorNumElements();
+ unsigned MaskBits = APInt(32, NumElts * 2).logBase2();
+ APInt ExpectedElt = APInt(MaskBits, *FirstRealElt + 1);
+ // The following shuffle indices must be the successive elements after the
+ // first real element.
+ const int *FirstWrongElt = std::find_if(FirstRealElt + 1, M.end(),
+ [&](int Elt) {return Elt != ExpectedElt++ && Elt != -1;});
+ if (FirstWrongElt != M.end())
+ return false;
- // If this is a VEXT shuffle, the immediate value is the index of the first
- // element. The other shuffle indices must be the successive elements after
- // the first one.
- unsigned ExpectedElt = Imm;
- for (unsigned i = 1; i < NumElts; ++i) {
- // Increment the expected index. If it wraps around, it may still be
- // a VEXT but the source vectors must be swapped.
- ExpectedElt += 1;
- if (ExpectedElt == NumElts * 2) {
- ExpectedElt = 0;
- ReverseEXT = true;
- }
-
- if (M[i] < 0)
- continue; // ignore UNDEF indices
- if (ExpectedElt != static_cast<unsigned>(M[i]))
- return false;
- }
+ // The index of an EXT is the first element if it is not UNDEF.
+ // Watch out for the beginning UNDEFs. The EXT index should be the expected
+ // value of the first element.
+ // E.g. <-1, -1, 3, ...> is treated as <1, 2, 3, ...>.
+ // <-1, -1, 0, 1, ...> is treated as <IDX, IDX+1, 0, 1, ...>. IDX is
+ // equal to the ExpectedElt. For this case, ExpectedElt is (NumElts*2 - 2).
+ Imm = (M[0] >= 0) ? static_cast<unsigned>(M[0]) : ExpectedElt.getZExtValue();
// Adjust the index value if the source operands will be swapped.
- if (ReverseEXT)
+ if (Imm >= NumElts) {
+ ReverseEXT = true;
Imm -= NumElts;
+ }
return true;
}
Modified: llvm/trunk/test/CodeGen/ARM64/ext.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/ARM64/ext.ll?rev=207485&r1=207484&r2=207485&view=diff
==============================================================================
--- llvm/trunk/test/CodeGen/ARM64/ext.ll (original)
+++ llvm/trunk/test/CodeGen/ARM64/ext.ll Mon Apr 28 20:50:36 2014
@@ -65,6 +65,15 @@ define <8 x i8> @test_vextd_undef(<8 x i
ret <8 x i8> %tmp3
}
+define <8 x i8> @test_vextd_undef2(<8 x i8>* %A, <8 x i8>* %B) nounwind {
+;CHECK-LABEL: test_vextd_undef2:
+;CHECK: {{ext.8b.*#6}}
+ %tmp1 = load <8 x i8>* %A
+ %tmp2 = load <8 x i8>* %B
+ %tmp3 = shufflevector <8 x i8> %tmp1, <8 x i8> %tmp2, <8 x i32> <i32 undef, i32 undef, i32 undef, i32 undef, i32 2, i32 3, i32 4, i32 5>
+ ret <8 x i8> %tmp3
+}
+
define <16 x i8> @test_vextRq_undef(<16 x i8>* %A, <16 x i8>* %B) nounwind {
;CHECK-LABEL: test_vextRq_undef:
;CHECK: {{ext.16b.*#7}}
@@ -74,6 +83,14 @@ define <16 x i8> @test_vextRq_undef(<16
ret <16 x i8> %tmp3
}
+define <8 x i16> @test_vextRq_undef2(<8 x i16>* %A) nounwind {
+;CHECK-LABEL: test_vextRq_undef2:
+;CHECK: {{ext.16b.*#10}}
+ %tmp1 = load <8 x i16>* %A
+ %vext = shufflevector <8 x i16> %tmp1, <8 x i16> undef, <8 x i32> <i32 undef, i32 undef, i32 undef, i32 undef, i32 1, i32 2, i32 3, i32 4>
+ ret <8 x i16> %vext;
+}
+
; Tests for ReconstructShuffle function. Indices have to be carefully
; chosen to reach lowering phase as a BUILD_VECTOR.
More information about the llvm-commits
mailing list