[llvm] r207303 - Revert commit r207302 since build failures
Gerolf Hoflehner
ghoflehner at apple.com
Mon Apr 28 19:16:32 PDT 2014
Restored in 207308.
-Gerolf
On Apr 26, 2014, at 2:46 AM, Pasi Parviainen <pasi.parviainen at iki.fi> wrote:
> So, what is up with the CloneFunction.cpp changes, since r207302 didn't touch it? Some WIP changes that got mangled with the revert?
>
> Pasi
>
> On 26.4.2014 5:03, Gerolf Hoflehner wrote:
>> Author: ghoflehner
>> Date: Fri Apr 25 21:03:17 2014
>> New Revision: 207303
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=207303&view=rev
>> Log:
>> Revert commit r207302 since build failures
>> have been reported.
>>
>> Removed:
>> llvm/trunk/test/Transforms/InstSimplify/dead-code-removal.ll
>> Modified:
>> llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
>> llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
>> llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp
>>
>> Modified: llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp?rev=207303&r1=207302&r2=207303&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp (original)
>> +++ llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp Fri Apr 25 21:03:17 2014
>> @@ -127,15 +127,7 @@ bool LoopInstSimplify::runOnLoop(Loop *L
>> ++NumSimplified;
>> }
>> }
>> - bool res = RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
>> - if (res) {
>> - // RecursivelyDeleteTriviallyDeadInstruction can remove
>> - // more than one instruction, so simply incrementing the
>> - // iterator does not work. When instructions get deleted
>> - // re-iterate instead.
>> - BI = BB->begin(); BE = BB->end();
>> - LocalChanged |= res;
>> - }
>> + LocalChanged |= RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
>>
>> if (IsSubloopHeader && !isa<PHINode>(I))
>> break;
>>
>> Modified: llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp?rev=207303&r1=207302&r2=207303&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp (original)
>> +++ llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp Fri Apr 25 21:03:17 2014
>> @@ -32,6 +32,7 @@
>> #include "llvm/Transforms/Utils/Local.h"
>> #include "llvm/Transforms/Utils/ValueMapper.h"
>> #include <map>
>> +#include <set>
>> using namespace llvm;
>>
>> // CloneBasicBlock - See comments in Cloning.h
>> @@ -272,42 +273,28 @@ namespace {
>> NameSuffix(nameSuffix), CodeInfo(codeInfo), DL(DL) {
>> }
>>
>> - /// CloneBlock - The specified block is found to be reachable, clone it and
>> - /// anything that it can reach.
>> + /// CloneBlock - The specified block is found to be reachable, so clone it
>> + /// into newBB.
>> void CloneBlock(const BasicBlock *BB,
>> - std::vector<const BasicBlock*> &ToClone);
>> + BasicBlock *NewBB,
>> + std::vector<const BasicBlock *> &ToClone,
>> + std::set<const BasicBlock *> &OrigBBs);
>> };
>> }
>>
>> -/// CloneBlock - The specified block is found to be reachable, clone it and
>> -/// anything that it can reach.
>> +/// CloneBlock - The specified block is found to be reachable, so clone it
>> +/// into newBB.
>> void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
>> - std::vector<const BasicBlock*> &ToClone){
>> - WeakVH &BBEntry = VMap[BB];
>> -
>> - // Have we already cloned this block?
>> - if (BBEntry) return;
>> + BasicBlock *NewBB,
>> + std::vector<const BasicBlock *> &ToClone,
>> + std::set<const BasicBlock *> &OrigBBs) {
>>
>> - // Nope, clone it now.
>> - BasicBlock *NewBB;
>> - BBEntry = NewBB = BasicBlock::Create(BB->getContext());
>> - if (BB->hasName()) NewBB->setName(BB->getName()+NameSuffix);
>> + // Remove BB from list of blocks to clone.
>> + // When it was not in the list, it has been cloned already, so
>> + // don't clone again.
>> + if (!OrigBBs.erase(BB)) return;
>>
>> - // It is only legal to clone a function if a block address within that
>> - // function is never referenced outside of the function. Given that, we
>> - // want to map block addresses from the old function to block addresses in
>> - // the clone. (This is different from the generic ValueMapper
>> - // implementation, which generates an invalid blockaddress when
>> - // cloning a function.)
>> - //
>> - // Note that we don't need to fix the mapping for unreachable blocks;
>> - // the default mapping there is safe.
>> - if (BB->hasAddressTaken()) {
>> - Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
>> - const_cast<BasicBlock*>(BB));
>> - VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
>> - }
>> -
>> + // Nope, clone it now.
>>
>> bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false;
>>
>> @@ -425,7 +412,7 @@ void llvm::CloneAndPruneFunctionInto(Fun
>> const DataLayout *DL,
>> Instruction *TheCall) {
>> assert(NameSuffix && "NameSuffix cannot be null!");
>> -
>> +
>> #ifndef NDEBUG
>> for (Function::const_arg_iterator II = OldFunc->arg_begin(),
>> E = OldFunc->arg_end(); II != E; ++II)
>> @@ -435,15 +422,87 @@ void llvm::CloneAndPruneFunctionInto(Fun
>> PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,
>> NameSuffix, CodeInfo, DL);
>>
>> - // Clone the entry block, and anything recursively reachable from it.
>> + // Since all BB address references need to be known before block-by-block
>> + // processing, we need to create all reachable blocks before processing
>> + // them for instruction cloning and pruning. Some of these blocks may
>> + // be removed due to later pruning.
>> std::vector<const BasicBlock*> CloneWorklist;
>> + //
>> + // OrigBBs consists of all blocks reachable from the entry
>> + // block.
>> + // This list will be pruned down by the CloneFunction() currently
>> + // (March 2014) due to two optimizations:
>> + // First, when a conditional branch target is known at compile-time,
>> + // only the actual branch destination block needs to be cloned.
>> + // Second, when a switch statement target is known at compile-time,
>> + // only the actual case statement needs to be cloned.
>> + std::set<const BasicBlock*> OrigBBs;
>> +
>> + CloneWorklist.push_back(&OldFunc->getEntryBlock());
>> + while (!CloneWorklist.empty()) {
>> + const BasicBlock *BB = CloneWorklist.back();
>> + CloneWorklist.pop_back();
>> +
>> + // Don't revisit blocks.
>> + if (VMap.count(BB))
>> + continue;
>> +
>> + BasicBlock *NewBB = BasicBlock::Create(BB->getContext());
>> + if (BB->hasName()) NewBB->setName(BB->getName()+NameSuffix);
>> +
>> + // It is only legal to clone a function if a block address within that
>> + // function is never referenced outside of the function. Given that, we
>> + // want to map block addresses from the old function to block addresses in
>> + // the clone. (This is different from the generic ValueMapper
>> + // implementation, which generates an invalid blockaddress when
>> + // cloning a function.)
>> + //
>> + // Note that we don't need to fix the mapping for unreachable blocks;
>> + // the default mapping there is safe.
>> + if (BB->hasAddressTaken()) {
>> + Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
>> + const_cast<BasicBlock*>(BB));
>> + VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
>> + }
>> +
>> + OrigBBs.insert(BB);
>> + VMap[BB] = NewBB;
>> + // Iterate over all possible successors and add them to the CloneWorklist.
>> + const TerminatorInst *Term = BB->getTerminator();
>> + for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
>> + BasicBlock *Succ = Term->getSuccessor(i);
>> + CloneWorklist.push_back(Succ);
>> + }
>> + }
>> +
>> + // Now, fill only the reachable blocks with the cloned contents
>> + // of the originals.
>> + assert(CloneWorklist.empty() && "Dirty worklist before re-use\n");
>> CloneWorklist.push_back(&OldFunc->getEntryBlock());
>> while (!CloneWorklist.empty()) {
>> const BasicBlock *BB = CloneWorklist.back();
>> CloneWorklist.pop_back();
>> - PFC.CloneBlock(BB, CloneWorklist);
>> + PFC.CloneBlock(BB, cast<BasicBlock>(VMap[BB]), CloneWorklist,
>> + OrigBBs);
>> }
>> -
>> +
>> + // Removed BB's that were created that turned out to be prunable.
>> + // Actual cloning may have found pruning opportunities since
>> + // branch or switch statement target may have been known at compile-time.
>> + // Alternatively we could write a routine CloneFunction and add a) a
>> + // parameter to actually do the cloning and b) a return parameter that
>> + // gives a list of blocks that need to be cloned also. Then we could
>> + // call CloneFunction when we collect the blocks to call, but suppress
>> + // cloning. And actually *do* the cloning in the while loop above. Also
>> + // the cleanup here would become redundant, and so would be the OrigBBs.
>> + for (std::set<const BasicBlock *>::iterator Oi = OrigBBs.begin(),
>> + Oe = OrigBBs.end(); Oi != Oe; ++Oi) {
>> + const BasicBlock *Orig = *Oi;
>> + BasicBlock *NewBB = cast<BasicBlock>(VMap[Orig]);
>> + delete NewBB;
>> + VMap[Orig] = 0;
>> + }
>> +
>> // Loop over all of the basic blocks in the old function. If the block was
>> // reachable, we have cloned it and the old block is now in the value map:
>> // insert it into the new function in the right order. If not, ignore it.
>>
>> Modified: llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp?rev=207303&r1=207302&r2=207303&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp (original)
>> +++ llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp Fri Apr 25 21:03:17 2014
>> @@ -76,15 +76,7 @@ namespace {
>> ++NumSimplified;
>> Changed = true;
>> }
>> - bool res = RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
>> - if (res) {
>> - // RecursivelyDeleteTriviallyDeadInstruction can remove
>> - // more than one instruction, so simply incrementing the
>> - // iterator does not work. When instructions get deleted
>> - // re-iterate instead.
>> - BI = BB->begin(); BE = BB->end();
>> - Changed |= res;
>> - }
>> + Changed |= RecursivelyDeleteTriviallyDeadInstructions(I, TLI);
>> }
>>
>> // Place the list of instructions to simplify on the next loop iteration
>>
>> Removed: llvm/trunk/test/Transforms/InstSimplify/dead-code-removal.ll
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstSimplify/dead-code-removal.ll?rev=207302&view=auto
>> ==============================================================================
>> --- llvm/trunk/test/Transforms/InstSimplify/dead-code-removal.ll (original)
>> +++ llvm/trunk/test/Transforms/InstSimplify/dead-code-removal.ll (removed)
>> @@ -1,15 +0,0 @@
>> -; RUN: opts -instsimplify -S < %s | FileCheck %s
>> -
>> -define void @foo() nounwind {
>> - br i1 undef, label %1, label %4
>> -
>> -; <label>:1 ; preds = %1, %0
>> -; CHECK-NOT: phi
>> -; CHECK-NOT: sub
>> - %2 = phi i32 [ %3, %1 ], [ undef, %0 ]
>> - %3 = sub i32 0, undef
>> - br label %1
>> -
>> -; <label>:4 ; preds = %0
>> - ret void
>> -}
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>>
>
More information about the llvm-commits
mailing list