RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity

Fix some places where we were assuming that memory type had been legalized

Browse Source 
to a simple type when lowering a truncating store of a vector type. In this
case for an EVT we'll return Expand as we should in all of the cases anyhow.

The testcase triggered at the one in VectorLegalizer::LegalizeOp, inspection
found the rest.

llvm-svn: 254061
This commit is contained in:
Eric Christopher 2015-11-25 09:11:53 +00:00
parent 5bd89dab62
commit 5f84aed4f6
4 changed files with 56 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/llvm/CodeGen/BasicTTIImpl.h
View File

@ -496,13 +496,11 @@ public:
// itself. Unless the corresponding extending load or truncating store is
// legal, then this will scalarize.
TargetLowering::LegalizeAction LA = TargetLowering::Expand;
EVT MemVT = getTLI()->getValueType(DL, Src, true);
if (MemVT.isSimple() && MemVT != MVT::Other) {
if (Opcode == Instruction::Store)
LA = getTLI()->getTruncStoreAction(LT.second, MemVT.getSimpleVT());
else
LA = getTLI()->getLoadExtAction(ISD::EXTLOAD, LT.second, MemVT);
}
EVT MemVT = getTLI()->getValueType(DL, Src);
if (Opcode == Instruction::Store)
LA = getTLI()->getTruncStoreAction(LT.second, MemVT);
else
LA = getTLI()->getLoadExtAction(ISD::EXTLOAD, LT.second, MemVT);
if (LA != TargetLowering::Legal && LA != TargetLowering::Custom) {
// This is a vector load/store for some illegal type that is scalarized.

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

@ -844,8 +844,7 @@ void SelectionDAGLegalize::LegalizeStoreOps(SDNode *Node) {
SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
ReplaceNode(SDValue(Node, 0), Result);
} else {
switch (TLI.getTruncStoreAction(ST->getValue().getSimpleValueType(),
StVT.getSimpleVT())) {
switch (TLI.getTruncStoreAction(ST->getValue().getValueType(), StVT)) {
default: llvm_unreachable("This action is not supported yet!");
case TargetLowering::Legal: {
EVT MemVT = ST->getMemoryVT();

2
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
View File

@ -231,7 +231,7 @@ SDValue VectorLegalizer::LegalizeOp(SDValue Op) {
EVT StVT = ST->getMemoryVT();
MVT ValVT = ST->getValue().getSimpleValueType();
if (StVT.isVector() && ST->isTruncatingStore())
switch (TLI.getTruncStoreAction(ValVT, StVT.getSimpleVT())) {
switch (TLI.getTruncStoreAction(ValVT, StVT)) {
default: llvm_unreachable("This action is not supported yet!");
case TargetLowering::Legal:
return TranslateLegalizeResults(Op, Result);

49
test/CodeGen/X86/trunc-store.ll Normal file
View File

@ -0,0 +1,49 @@
; RUN: llc < %s -march=x86-64 | FileCheck %s
; With optimization at O2 we actually get the legalized function optimized
; away through legalization and stack coloring, but check that we do all of
; that here and don't crash during legalization.
; Original program:
; typedef enum { A, B, C, D } P;
; struct { P x[2]; } a;
; void fn2();
; void fn1() {
; int b;
; unsigned c;
; for (;; c++) {
; fn2();
; unsigned n;
; for (; c; c++) {
; b = a.x[c] == A || a.x[c] == B || a.x[c] == D;
; if (b) n++;
; }
; if (n)
; for (;;)
; ;
; }
; }
define void @fn1() {
; CHECK-LABEL: fn1
; CHECK: movb $0, -8(%rsp)
; CHECK: cmpq $8, %rax
for.cond:
br label %vector.body
vector.body: ; preds = %vector.body, %for.cond
%x42 = bitcast <4 x i4> zeroinitializer to i16
%x43 = icmp ne i16 %x42, 0
%x44 = select i1 %x43, i32 undef, i32 0
%x72 = bitcast <4 x i1> zeroinitializer to i4
%x73 = icmp ne i4 %x72, 0
%x74 = select i1 %x73, i32 %x44, i32 undef
%x84 = select i1 undef, i32 undef, i32 %x74
%x88 = icmp eq i64 undef, 8
br i1 %x88, label %middle.block, label %vector.body
middle.block: ; preds = %vector.body
%0 = select i1 undef, i32 undef, i32 %x84
ret void
}