From 63c21deee15516723d3ebcf70ba34bb07116e974 Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Thu, 21 Apr 2011 16:14:46 +0000 Subject: [PATCH] Revert r1296656, "Fix rdar://9289512 - not folding load into compare at -O0...", which broke a couple GCC test suite tests at -O0. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@129914 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/SelectionDAGISel.h | 3 +- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 56 +++++-------------- test/CodeGen/X86/fast-isel-x86-64.ll | 22 -------- 3 files changed, 16 insertions(+), 65 deletions(-) diff --git a/include/llvm/CodeGen/SelectionDAGISel.h b/include/llvm/CodeGen/SelectionDAGISel.h index ecf39470105..e0cfabd0957 100644 --- a/include/llvm/CodeGen/SelectionDAGISel.h +++ b/include/llvm/CodeGen/SelectionDAGISel.h @@ -280,8 +280,7 @@ private: void PrepareEHLandingPad(); void SelectAllBasicBlocks(const Function &Fn); - bool TryToFoldFastISelLoad(const LoadInst *LI, const Instruction *FoldInst, - FastISel *FastIS); + bool TryToFoldFastISelLoad(const LoadInst *LI, FastISel *FastIS); void FinishBasicBlock(); void SelectBasicBlock(BasicBlock::const_iterator Begin, diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index af3188895ed..25dd97d0435 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -746,31 +746,9 @@ void SelectionDAGISel::PrepareEHLandingPad() { -/// TryToFoldFastISelLoad - We're checking to see if we can fold the specified -/// load into the specified FoldInst. Note that we could have a sequence where -/// multiple LLVM IR instructions are folded into the same machineinstr. For -/// example we could have: -/// A: x = load i32 *P -/// B: y = icmp A, 42 -/// C: br y, ... -/// -/// In this scenario, LI is "A", and FoldInst is "C". We know about "B" (and -/// any other folded instructions) because it is between A and C. -/// -/// If we succeed in folding the load into the operation, return true. -/// + bool SelectionDAGISel::TryToFoldFastISelLoad(const LoadInst *LI, - const Instruction *FoldInst, FastISel *FastIS) { - SmallPtrSet FoldedInsts; - for (BasicBlock::const_iterator II = FoldInst; &*II != LI; --II) - FoldedInsts.insert(II); - - // We know that the load has a single use, but don't know what it is. If it - // isn't one of the folded instructions, then we can't succeed here. - if (!FoldedInsts.count(LI->use_back())) - return false; - // Don't try to fold volatile loads. Target has to deal with alignment // constraints. if (LI->isVolatile()) return false; @@ -855,10 +833,10 @@ static void CheckLineNumbers(const MachineBasicBlock *MBB) { /// Return false if it needs to be emitted. static bool isFoldedOrDeadInstruction(const Instruction *I, FunctionLoweringInfo *FuncInfo) { - return !I->mayWriteToMemory() && // Side-effecting instructions aren't folded. - !isa(I) && // Terminators aren't folded. - !isa(I) && // Debug instructions aren't folded. - !FuncInfo->isExportedInst(I); // Exported instrs must be computed. + return !I->mayWriteToMemory() && + !isa(I) && + !isa(I) && + !FuncInfo->isExportedInst(I); } void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) { @@ -950,20 +928,16 @@ void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) { // Try to select the instruction with FastISel. if (FastIS->SelectInstruction(Inst)) { - // If fast isel succeeded, skip over all the folded instructions, and - // then see if there is a load right before the selected instructions. - // Try to fold the load if so. - const Instruction *BeforeInst = Inst; - while (BeforeInst != Begin) { - BeforeInst = llvm::prior(BasicBlock::const_iterator(BeforeInst)); - if (!isFoldedOrDeadInstruction(BeforeInst, FuncInfo)) - break; - } - if (BeforeInst != Inst && isa(BeforeInst) && - BeforeInst->hasOneUse() && - TryToFoldFastISelLoad(cast(BeforeInst), Inst, FastIS)) - // If we succeeded, don't re-select the load. - BI = llvm::next(BasicBlock::const_iterator(BeforeInst)); + // If fast isel succeeded, check to see if there is a single-use + // non-volatile load right before the selected instruction, and see if + // the load is used by the instruction. If so, try to fold it. + const Instruction *BeforeInst = 0; + if (Inst != Begin) + BeforeInst = llvm::prior(llvm::prior(BI)); + if (BeforeInst && isa(BeforeInst) && + BeforeInst->hasOneUse() && *BeforeInst->use_begin() == Inst && + TryToFoldFastISelLoad(cast(BeforeInst), FastIS)) + --BI; // If we succeeded, don't re-select the load. continue; } diff --git a/test/CodeGen/X86/fast-isel-x86-64.ll b/test/CodeGen/X86/fast-isel-x86-64.ll index 46659892983..5762ef33123 100644 --- a/test/CodeGen/X86/fast-isel-x86-64.ll +++ b/test/CodeGen/X86/fast-isel-x86-64.ll @@ -14,28 +14,6 @@ define i32 @test1(i32 %i) nounwind ssp { ; CHECK: andl $8, -; rdar://9289512 - The load should fold into the compare. -define void @test2(i64 %x) nounwind ssp { -entry: - %x.addr = alloca i64, align 8 - store i64 %x, i64* %x.addr, align 8 - %tmp = load i64* %x.addr, align 8 - %cmp = icmp sgt i64 %tmp, 42 - br i1 %cmp, label %if.then, label %if.end - -if.then: ; preds = %entry - br label %if.end - -if.end: ; preds = %if.then, %entry - ret void -; CHECK: test2: -; CHECK: movq %rdi, -8(%rsp) -; CHECK: cmpq $42, -8(%rsp) -} - - - - @G = external global i32 define i64 @test3() nounwind { %A = ptrtoint i32* @G to i64