RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-03-01 15:19:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix cycle in selection DAG introduced by extractelement legalization

Browse Source 
During selection DAG legalization, extractelement is replaced with a load
instruction.  To do this, a temporary store to the stack is used unless an
existing store is found that can be re-used.
    
If re-using a store, the chain going out of the store must be replaced by
the one going out of the new load (this ensures that any stores that must
take place after the store happens after the load, else the value might
be overwritten before it is loaded).
    
The problem is, if the extractelement index is dependent on the store
replacing the chain will introduce a cycle in the selection DAG (the load
uses the index, and by replacing the chain we will make the index dependent
on the load).
    
To fix this, if the index is dependent on the store, the store is skipped.
This is conservative as we may end up creating an unnecessary extra store
to the stack.  However, the situation is not expected to occur very often.

Differential Revision: http://reviews.llvm.org/D15330


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255114 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Robert Lougher 2015-12-09 14:34:10 +00:00
parent 43ecf2d4d1
commit c8a1727001
2 changed files with 32 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -1463,6 +1463,11 @@ SDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) {
// series of EXTRACT_VECTOR_ELT nodes are generated, one for each element in
// the vector. If all are expanded here, we don't want one store per vector
// element.
// Caches for hasPredecessorHelper
SmallPtrSet<const SDNode *, 32> Visited;
SmallVector<const SDNode *, 16> Worklist;
SDValue StackPtr, Ch;
for (SDNode::use_iterator UI = Vec.getNode()->use_begin(),
UE = Vec.getNode()->use_end(); UI != UE; ++UI) {
@ -1477,6 +1482,12 @@ SDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) {
if (!ST->getChain().reachesChainWithoutSideEffects(DAG.getEntryNode()))
continue;
// If the index is dependent on the store we will introduce a cycle when
// creating the load (the load uses the index, and by replacing the chain
// we will make the index dependent on the load).
if (Idx.getNode()->hasPredecessorHelper(ST, Visited, Worklist))
continue;
StackPtr = ST->getBasePtr();
Ch = SDValue(ST, 0);
break;

21
test/CodeGen/X86/extractelement-legalization-cycle.ll Normal file
View File

@ -0,0 +1,21 @@
; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s
; When the extractelement is converted to a load the store can be re-used.
; This will, however, introduce a cycle into the selection DAG (the load
; of the extractelement index is dependent on the store, and so after the
; conversion it becomes dependent on the new load, which is dependent on
; the index). Make sure we skip the store, and conservatively instead
; use a store to the stack.
define float @foo(i32* %i, <4 x float>* %v) {
; CHECK-LABEL: foo:
; CHECK: movaps %xmm0, -[[OFFSET:[0-9]+]](%rsp)
; CHECK: movss -[[OFFSET]](%rsp,{{.*}}), %xmm0 {{.*}}
; CHECK-NEXT: retq
%1 = load <4 x float>, <4 x float>* %v, align 16
%mul = fmul <4 x float> %1, %1
store <4 x float> %mul, <4 x float>* %v, align 16
%2 = load i32, i32* %i, align 4
%vecext = extractelement <4 x float> %mul, i32 %2
ret float %vecext
}