[llvm] r187764 - Factor FlattenCFG out from SimplifyCFG
Timur Iskhodzhanov
timurrrr at google.com
Tue Aug 6 01:52:02 PDT 2013
Thanks, you were faster at fixing this than me :)
2013/8/6 Serge Pavlov <sepavloff at gmail.com>:
> The problem is fixed in r187786.
>
>
> 2013/8/6 Timur Iskhodzhanov <timurrrr at google.com>
>>
>> FYI this has broken the MSVS build
>>
>> 100>------ Build started: Project: LLVMTransformUtils, Configuration:
>> Debug Win32 ------
>> ...
>> 100> FlattenCFG.cpp
>> 100> llvm\lib\Transforms\Utils\FlattenCFG.cpp(301):
>> error C2027: use of undefined type 'llvm::raw_ostream'
>>
>> 2013/8/6 Tom Stellard <thomas.stellard at amd.com>:
>> > Author: tstellar
>> > Date: Mon Aug 5 21:43:45 2013
>> > New Revision: 187764
>> >
>> > URL: http://llvm.org/viewvc/llvm-project?rev=187764&view=rev
>> > Log:
>> > Factor FlattenCFG out from SimplifyCFG
>> >
>> > Patch by: Mei Ye
>> >
>> > Added:
>> > llvm/trunk/lib/Transforms/Scalar/FlattenCFGPass.cpp
>> > llvm/trunk/lib/Transforms/Utils/FlattenCFG.cpp
>> > llvm/trunk/test/CodeGen/R600/parallelandifcollapse.ll
>> > - copied, changed from r187754,
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > llvm/trunk/test/CodeGen/R600/parallelorifcollapse.ll
>> > - copied, changed from r187754,
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > Modified:
>> > llvm/trunk/include/llvm/InitializePasses.h
>> > llvm/trunk/include/llvm/Transforms/Scalar.h
>> > llvm/trunk/include/llvm/Transforms/Utils/BasicBlockUtils.h
>> > llvm/trunk/include/llvm/Transforms/Utils/Local.h
>> > llvm/trunk/lib/Target/R600/AMDGPUTargetMachine.cpp
>> > llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp
>> > llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt
>> > llvm/trunk/lib/Transforms/Scalar/Scalar.cpp
>> > llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp
>> > llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp
>> > llvm/trunk/lib/Transforms/Utils/CMakeLists.txt
>> > llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/lit.local.cfg
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > llvm/trunk/test/Transforms/SimplifyCFG/lit.local.cfg
>> > llvm/trunk/tools/lto/LTOCodeGenerator.cpp
>> >
>> > Modified: llvm/trunk/include/llvm/InitializePasses.h
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InitializePasses.h?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/include/llvm/InitializePasses.h (original)
>> > +++ llvm/trunk/include/llvm/InitializePasses.h Mon Aug 5 21:43:45 2013
>> > @@ -86,8 +86,8 @@ void initializeCallGraphViewerPass(PassR
>> > void initializeCFGOnlyPrinterPass(PassRegistry&);
>> > void initializeCFGOnlyViewerPass(PassRegistry&);
>> > void initializeCFGPrinterPass(PassRegistry&);
>> > -void initializeCFGOptimizePass(PassRegistry&);
>> > -void initializeCFGCanonicalizePass(PassRegistry&);
>> > +void initializeCFGSimplifyPassPass(PassRegistry&);
>> > +void initializeFlattenCFGPassPass(PassRegistry&);
>> > void initializeStructurizeCFGPass(PassRegistry&);
>> > void initializeCFGViewerPass(PassRegistry&);
>> > void initializeCalculateSpillWeightsPass(PassRegistry&);
>> >
>> > Modified: llvm/trunk/include/llvm/Transforms/Scalar.h
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Scalar.h?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/include/llvm/Transforms/Scalar.h (original)
>> > +++ llvm/trunk/include/llvm/Transforms/Scalar.h Mon Aug 5 21:43:45 2013
>> > @@ -196,7 +196,14 @@ FunctionPass *createJumpThreadingPass();
>> > // CFGSimplification - Merge basic blocks, eliminate unreachable
>> > blocks,
>> > // simplify terminator instructions, etc...
>> > //
>> > -FunctionPass *createCFGSimplificationPass(bool IsTargetAware = false);
>> > +FunctionPass *createCFGSimplificationPass();
>> > +
>> >
>> > +//===----------------------------------------------------------------------===//
>> > +//
>> > +// FlattenCFG - flatten CFG, reduce number of conditional branches by
>> > using
>> > +// parallel-and and parallel-or mode, etc...
>> > +//
>> > +FunctionPass *createFlattenCFGPass();
>> >
>> >
>> > //===----------------------------------------------------------------------===//
>> > //
>> >
>> > Modified: llvm/trunk/include/llvm/Transforms/Utils/BasicBlockUtils.h
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/BasicBlockUtils.h?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/include/llvm/Transforms/Utils/BasicBlockUtils.h
>> > (original)
>> > +++ llvm/trunk/include/llvm/Transforms/Utils/BasicBlockUtils.h Mon Aug
>> > 5 21:43:45 2013
>> > @@ -205,6 +205,15 @@ ReturnInst *FoldReturnIntoUncondBranch(R
>> > TerminatorInst *SplitBlockAndInsertIfThen(Instruction *Cmp,
>> > bool Unreachable, MDNode *BranchWeights = 0);
>> >
>> > +///
>> > +/// GetIfCondition - Check whether BB is the merge point of a
>> > if-region.
>> > +/// If so, return the boolean condition that determines which entry
>> > into
>> > +/// BB will be taken. Also, return by references the block that will
>> > be
>> > +/// entered from if the condition is true, and the block that will be
>> > +/// entered if the condition is false.
>> > +
>> > +Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue,
>> > + BasicBlock *&IfFalse);
>> > } // End llvm namespace
>> >
>> > #endif
>> >
>> > Modified: llvm/trunk/include/llvm/Transforms/Utils/Local.h
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/Local.h?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/include/llvm/Transforms/Utils/Local.h (original)
>> > +++ llvm/trunk/include/llvm/Transforms/Utils/Local.h Mon Aug 5 21:43:45
>> > 2013
>> > @@ -137,7 +137,13 @@ bool EliminateDuplicatePHINodes(BasicBlo
>> > /// the basic block that was pointed to.
>> > ///
>> > bool SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
>> > - const DataLayout *TD = 0, AliasAnalysis *AA = 0);
>> > + const DataLayout *TD = 0);
>> > +
>> > +/// FlatternCFG - This function is used to flatten a CFG. For
>> > +/// example, it uses parallel-and and parallel-or mode to collapse
>> > +// if-conditions and merge if-regions with identical statements.
>> > +///
>> > +bool FlattenCFG(BasicBlock *BB, AliasAnalysis *AA = 0);
>> >
>> > /// FoldBranchToCommonDest - If this basic block is ONLY a setcc and a
>> > branch,
>> > /// and if a predecessor branches to us and one of our successors, fold
>> > the
>> >
>> > Modified: llvm/trunk/lib/Target/R600/AMDGPUTargetMachine.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/R600/AMDGPUTargetMachine.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Target/R600/AMDGPUTargetMachine.cpp (original)
>> > +++ llvm/trunk/lib/Target/R600/AMDGPUTargetMachine.cpp Mon Aug 5
>> > 21:43:45 2013
>> > @@ -91,7 +91,6 @@ public:
>> > AMDGPUTargetMachine &getAMDGPUTargetMachine() const {
>> > return getTM<AMDGPUTargetMachine>();
>> > }
>> > -
>> > virtual bool addPreISel();
>> > virtual bool addInstSelector();
>> > virtual bool addPreRegAlloc();
>> > @@ -120,6 +119,7 @@ void AMDGPUTargetMachine::addAnalysisPas
>> > bool
>> > AMDGPUPassConfig::addPreISel() {
>> > const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
>> > + addPass(createFlattenCFGPass());
>> > if (ST.getGeneration() > AMDGPUSubtarget::NORTHERN_ISLANDS) {
>> > addPass(createStructurizeCFGPass());
>> > addPass(createSIAnnotateControlFlowPass());
>> >
>> > Modified: llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp (original)
>> > +++ llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp Mon Aug 5
>> > 21:43:45 2013
>> > @@ -235,7 +235,7 @@ void PassManagerBuilder::populateModuleP
>> > }
>> >
>> > MPM.add(createAggressiveDCEPass()); // Delete dead
>> > instructions
>> > - MPM.add(createCFGSimplificationPass(true)); // Merge & remove BBs
>> > + MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
>> > MPM.add(createInstructionCombiningPass()); // Clean up after
>> > everything.
>> >
>> > // As an experimental mode, run any vectorization passes in a
>> > separate
>> > @@ -371,7 +371,7 @@ void PassManagerBuilder::populateLTOPass
>> > PM.add(createJumpThreadingPass());
>> >
>> > // Delete basic blocks, which optimization passes may have killed.
>> > - PM.add(createCFGSimplificationPass(true));
>> > + PM.add(createCFGSimplificationPass());
>> >
>> > // Now that we have optimized the program, discard unreachable
>> > functions.
>> > PM.add(createGlobalDCEPass());
>> >
>> > Modified: llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt (original)
>> > +++ llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt Mon Aug 5 21:43:45
>> > 2013
>> > @@ -28,6 +28,7 @@ add_llvm_library(LLVMScalarOpts
>> > Scalar.cpp
>> > ScalarReplAggregates.cpp
>> > SimplifyCFGPass.cpp
>> > + FlattenCFGPass.cpp
>> > Sink.cpp
>> > StructurizeCFG.cpp
>> > TailRecursionElimination.cpp
>> >
>> > Added: llvm/trunk/lib/Transforms/Scalar/FlattenCFGPass.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/FlattenCFGPass.cpp?rev=187764&view=auto
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Scalar/FlattenCFGPass.cpp (added)
>> > +++ llvm/trunk/lib/Transforms/Scalar/FlattenCFGPass.cpp Mon Aug 5
>> > 21:43:45 2013
>> > @@ -0,0 +1,79 @@
>> > +//===- FlattenCFGPass.cpp - CFG Flatten Pass
>> > ----------------------===//
>> > +//
>> > +// The LLVM Compiler Infrastructure
>> > +//
>> > +// This file is distributed under the University of Illinois Open
>> > Source
>> > +// License. See LICENSE.TXT for details.
>> > +//
>> >
>> > +//===----------------------------------------------------------------------===//
>> > +//
>> > +// This file implements flattening of CFG.
>> > +//
>> >
>> > +//===----------------------------------------------------------------------===//
>> > +
>> > +#define DEBUG_TYPE "flattencfg"
>> > +#include "llvm/Transforms/Scalar.h"
>> > +#include "llvm/Analysis/AliasAnalysis.h"
>> > +#include "llvm/Pass.h"
>> > +#include "llvm/Support/CFG.h"
>> > +#include "llvm/Transforms/Utils/Local.h"
>> > +using namespace llvm;
>> > +
>> > +namespace {
>> > +struct FlattenCFGPass : public FunctionPass {
>> > + static char ID; // Pass identification, replacement for typeid
>> > +public:
>> > + FlattenCFGPass() : FunctionPass(ID) {
>> > + initializeFlattenCFGPassPass(*PassRegistry::getPassRegistry());
>> > + }
>> > + bool runOnFunction(Function &F);
>> > +
>> > + void getAnalysisUsage(AnalysisUsage &AU) const {
>> > + AU.addRequired<AliasAnalysis>();
>> > + }
>> > +
>> > +private:
>> > + AliasAnalysis *AA;
>> > +};
>> > +}
>> > +
>> > +char FlattenCFGPass::ID = 0;
>> > +INITIALIZE_PASS_BEGIN(FlattenCFGPass, "flattencfg", "Flatten the CFG",
>> > false,
>> > + false)
>> > +INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
>> > +INITIALIZE_PASS_END(FlattenCFGPass, "flattencfg", "Flatten the CFG",
>> > false,
>> > + false)
>> > +
>> > +// Public interface to the FlattenCFG pass
>> > +FunctionPass *llvm::createFlattenCFGPass() { return new
>> > FlattenCFGPass(); }
>> > +
>> > +/// iterativelyFlattenCFG - Call FlattenCFG on all the blocks in the
>> > function,
>> > +/// iterating until no more changes are made.
>> > +static bool iterativelyFlattenCFG(Function &F, AliasAnalysis *AA) {
>> > + bool Changed = false;
>> > + bool LocalChange = true;
>> > + while (LocalChange) {
>> > + LocalChange = false;
>> > +
>> > + // Loop over all of the basic blocks and remove them if they are
>> > unneeded...
>> > + //
>> > + for (Function::iterator BBIt = F.begin(); BBIt != F.end();) {
>> > + if (FlattenCFG(BBIt++, AA)) {
>> > + LocalChange = true;
>> > + }
>> > + }
>> > + Changed |= LocalChange;
>> > + }
>> > + return Changed;
>> > +}
>> > +
>> > +bool FlattenCFGPass::runOnFunction(Function &F) {
>> > + AA = &getAnalysis<AliasAnalysis>();
>> > + bool EverChanged = false;
>> > + // iterativelyFlattenCFG can make some blocks dead.
>> > + while (iterativelyFlattenCFG(F, AA)) {
>> > + removeUnreachableBlocks(F);
>> > + EverChanged = true;
>> > + }
>> > + return EverChanged;
>> > +}
>> >
>> > Modified: llvm/trunk/lib/Transforms/Scalar/Scalar.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/Scalar.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Scalar/Scalar.cpp (original)
>> > +++ llvm/trunk/lib/Transforms/Scalar/Scalar.cpp Mon Aug 5 21:43:45 2013
>> > @@ -57,8 +57,7 @@ void llvm::initializeScalarOpts(PassRegi
>> > initializeSROAPass(Registry);
>> > initializeSROA_DTPass(Registry);
>> > initializeSROA_SSAUpPass(Registry);
>> > - initializeCFGCanonicalizePass(Registry);
>> > - initializeCFGOptimizePass(Registry);
>> > + initializeCFGSimplifyPassPass(Registry);
>> > initializeStructurizeCFGPass(Registry);
>> > initializeSinkingPass(Registry);
>> > initializeTailCallElimPass(Registry);
>> >
>> > Modified: llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp (original)
>> > +++ llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp Mon Aug 5
>> > 21:43:45 2013
>> > @@ -27,7 +27,6 @@
>> > #include "llvm/ADT/SmallVector.h"
>> > #include "llvm/ADT/Statistic.h"
>> > #include "llvm/Analysis/TargetTransformInfo.h"
>> > -#include "llvm/Analysis/AliasAnalysis.h"
>> > #include "llvm/IR/Attributes.h"
>> > #include "llvm/IR/Constants.h"
>> > #include "llvm/IR/DataLayout.h"
>> > @@ -43,61 +42,28 @@ STATISTIC(NumSimpl, "Number of blocks si
>> >
>> > namespace {
>> > struct CFGSimplifyPass : public FunctionPass {
>> > - CFGSimplifyPass(char &ID, bool isTargetAware)
>> > - : FunctionPass(ID), IsTargetAware(isTargetAware) {}
>> > - virtual bool runOnFunction(Function &F);
>> > -
>> > - virtual void getAnalysisUsage(AnalysisUsage &AU) const {
>> > - AU.addRequired<TargetTransformInfo>();
>> > - }
>> > -private:
>> > - AliasAnalysis *AA;
>> > - bool IsTargetAware; // Should the pass be target-aware?
>> > -};
>> > -
>> > -// CFGSimplifyPass that does optimizations.
>> > -struct CFGOptimize : public CFGSimplifyPass {
>> > static char ID; // Pass identification, replacement for typeid
>> > -public:
>> > - CFGOptimize() : CFGSimplifyPass(ID, true) {
>> > - initializeCFGOptimizePass(*PassRegistry::getPassRegistry());
>> > + CFGSimplifyPass() : FunctionPass(ID) {
>> > + initializeCFGSimplifyPassPass(*PassRegistry::getPassRegistry());
>> > }
>> > + virtual bool runOnFunction(Function &F);
>> > +
>> > virtual void getAnalysisUsage(AnalysisUsage &AU) const {
>> > AU.addRequired<TargetTransformInfo>();
>> > - AU.addRequired<AliasAnalysis>();
>> > - }
>> > -};
>> > -
>> > -// CFGSimplifyPass that does canonicalizations.
>> > -struct CFGCanonicalize : public CFGSimplifyPass {
>> > - static char ID; // Pass identification, replacement for typeid
>> > -public:
>> > - CFGCanonicalize() : CFGSimplifyPass(ID, false) {
>> > - initializeCFGCanonicalizePass(*PassRegistry::getPassRegistry());
>> > }
>> > };
>> > }
>> >
>> > -char CFGCanonicalize::ID = 0;
>> > -char CFGOptimize::ID = 0;
>> > -INITIALIZE_PASS_BEGIN(CFGCanonicalize, "simplifycfg", "Simplify the
>> > CFG", false,
>> > - false)
>> > -INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
>> > -INITIALIZE_PASS_END(CFGCanonicalize, "simplifycfg", "Simplify the CFG",
>> > false,
>> > - false)
>> > -INITIALIZE_PASS_BEGIN(CFGOptimize, "optimizecfg", "optimize the CFG",
>> > false,
>> > +char CFGSimplifyPass::ID = 0;
>> > +INITIALIZE_PASS_BEGIN(CFGSimplifyPass, "simplifycfg", "Simplify the
>> > CFG", false,
>> > false)
>> > INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
>> > -INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
>> > -INITIALIZE_PASS_END(CFGOptimize, "optimizecfg", "Optimize the CFG",
>> > false,
>> > +INITIALIZE_PASS_END(CFGSimplifyPass, "simplifycfg", "Simplify the CFG",
>> > false,
>> > false)
>> >
>> > // Public interface to the CFGSimplification pass
>> > -FunctionPass *llvm::createCFGSimplificationPass(bool IsTargetAware) {
>> > - if (IsTargetAware)
>> > - return new CFGOptimize();
>> > - else
>> > - return new CFGCanonicalize();
>> > +FunctionPass *llvm::createCFGSimplificationPass() {
>> > + return new CFGSimplifyPass();
>> > }
>> >
>> > /// changeToUnreachable - Insert an unreachable instruction before the
>> > specified
>> > @@ -334,7 +300,7 @@ static bool mergeEmptyReturnBlocks(Funct
>> > /// iterativelySimplifyCFG - Call SimplifyCFG on all the blocks in the
>> > function,
>> > /// iterating until no more changes are made.
>> > static bool iterativelySimplifyCFG(Function &F, const
>> > TargetTransformInfo &TTI,
>> > - const DataLayout *TD, AliasAnalysis
>> > *AA) {
>> > + const DataLayout *TD) {
>> > bool Changed = false;
>> > bool LocalChange = true;
>> > while (LocalChange) {
>> > @@ -343,7 +309,7 @@ static bool iterativelySimplifyCFG(Funct
>> > // Loop over all of the basic blocks and remove them if they are
>> > unneeded...
>> > //
>> > for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) {
>> > - if (SimplifyCFG(BBIt++, TTI, TD, AA)) {
>> > + if (SimplifyCFG(BBIt++, TTI, TD)) {
>> > LocalChange = true;
>> > ++NumSimpl;
>> > }
>> > @@ -357,15 +323,11 @@ static bool iterativelySimplifyCFG(Funct
>> > // simplify the CFG.
>> > //
>> > bool CFGSimplifyPass::runOnFunction(Function &F) {
>> > - if (IsTargetAware)
>> > - AA = &getAnalysis<AliasAnalysis>();
>> > - else
>> > - AA = NULL;
>> > const TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
>> > const DataLayout *TD = getAnalysisIfAvailable<DataLayout>();
>> > bool EverChanged = removeUnreachableBlocksFromFn(F);
>> > EverChanged |= mergeEmptyReturnBlocks(F);
>> > - EverChanged |= iterativelySimplifyCFG(F, TTI, TD, AA);
>> > + EverChanged |= iterativelySimplifyCFG(F, TTI, TD);
>> >
>> > // If neither pass changed anything, we're done.
>> > if (!EverChanged) return false;
>> > @@ -379,7 +341,7 @@ bool CFGSimplifyPass::runOnFunction(Func
>> > return true;
>> >
>> > do {
>> > - EverChanged = iterativelySimplifyCFG(F, TTI, TD, AA);
>> > + EverChanged = iterativelySimplifyCFG(F, TTI, TD);
>> > EverChanged |= removeUnreachableBlocksFromFn(F);
>> > } while (EverChanged);
>> >
>> >
>> > Modified: llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp (original)
>> > +++ llvm/trunk/lib/Transforms/Utils/BasicBlockUtils.cpp Mon Aug 5
>> > 21:43:45 2013
>> > @@ -665,3 +665,104 @@ TerminatorInst *llvm::SplitBlockAndInser
>> > ReplaceInstWithInst(HeadOldTerm, HeadNewTerm);
>> > return CheckTerm;
>> > }
>> > +
>> > +/// GetIfCondition - Given a basic block (BB) with two predecessors,
>> > +/// check to see if the merge at this block is due
>> > +/// to an "if condition". If so, return the boolean condition that
>> > determines
>> > +/// which entry into BB will be taken. Also, return by references the
>> > block
>> > +/// that will be entered from if the condition is true, and the block
>> > that will
>> > +/// be entered if the condition is false.
>> > +///
>> > +/// This does no checking to see if the true/false blocks have large or
>> > unsavory
>> > +/// instructions in them.
>> > +Value *llvm::GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue,
>> > + BasicBlock *&IfFalse) {
>> > + PHINode *SomePHI = dyn_cast<PHINode>(BB->begin());
>> > + BasicBlock *Pred1 = NULL;
>> > + BasicBlock *Pred2 = NULL;
>> > +
>> > + if (SomePHI) {
>> > + if (SomePHI->getNumIncomingValues() != 2)
>> > + return NULL;
>> > + Pred1 = SomePHI->getIncomingBlock(0);
>> > + Pred2 = SomePHI->getIncomingBlock(1);
>> > + } else {
>> > + pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
>> > + if (PI == PE) // No predecessor
>> > + return NULL;
>> > + Pred1 = *PI++;
>> > + if (PI == PE) // Only one predecessor
>> > + return NULL;
>> > + Pred2 = *PI++;
>> > + if (PI != PE) // More than two predecessors
>> > + return NULL;
>> > + }
>> > +
>> > + // We can only handle branches. Other control flow will be lowered
>> > to
>> > + // branches if possible anyway.
>> > + BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator());
>> > + BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator());
>> > + if (Pred1Br == 0 || Pred2Br == 0)
>> > + return 0;
>> > +
>> > + // Eliminate code duplication by ensuring that Pred1Br is conditional
>> > if
>> > + // either are.
>> > + if (Pred2Br->isConditional()) {
>> > + // If both branches are conditional, we don't have an "if
>> > statement". In
>> > + // reality, we could transform this case, but since the condition
>> > will be
>> > + // required anyway, we stand no chance of eliminating it, so the
>> > xform is
>> > + // probably not profitable.
>> > + if (Pred1Br->isConditional())
>> > + return 0;
>> > +
>> > + std::swap(Pred1, Pred2);
>> > + std::swap(Pred1Br, Pred2Br);
>> > + }
>> > +
>> > + if (Pred1Br->isConditional()) {
>> > + // The only thing we have to watch out for here is to make sure
>> > that Pred2
>> > + // doesn't have incoming edges from other blocks. If it does, the
>> > condition
>> > + // doesn't dominate BB.
>> > + if (Pred2->getSinglePredecessor() == 0)
>> > + return 0;
>> > +
>> > + // If we found a conditional branch predecessor, make sure that it
>> > branches
>> > + // to BB and Pred2Br. If it doesn't, this isn't an "if statement".
>> > + if (Pred1Br->getSuccessor(0) == BB &&
>> > + Pred1Br->getSuccessor(1) == Pred2) {
>> > + IfTrue = Pred1;
>> > + IfFalse = Pred2;
>> > + } else if (Pred1Br->getSuccessor(0) == Pred2 &&
>> > + Pred1Br->getSuccessor(1) == BB) {
>> > + IfTrue = Pred2;
>> > + IfFalse = Pred1;
>> > + } else {
>> > + // We know that one arm of the conditional goes to BB, so the
>> > other must
>> > + // go somewhere unrelated, and this must not be an "if
>> > statement".
>> > + return 0;
>> > + }
>> > +
>> > + return Pred1Br->getCondition();
>> > + }
>> > +
>> > + // Ok, if we got here, both predecessors end with an unconditional
>> > branch to
>> > + // BB. Don't panic! If both blocks only have a single (identical)
>> > + // predecessor, and THAT is a conditional branch, then we're all ok!
>> > + BasicBlock *CommonPred = Pred1->getSinglePredecessor();
>> > + if (CommonPred == 0 || CommonPred != Pred2->getSinglePredecessor())
>> > + return 0;
>> > +
>> > + // Otherwise, if this is a conditional branch, then we can use it!
>> > + BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator());
>> > + if (BI == 0) return 0;
>> > +
>> > + assert(BI->isConditional() && "Two successors but not conditional?");
>> > + if (BI->getSuccessor(0) == Pred1) {
>> > + IfTrue = Pred1;
>> > + IfFalse = Pred2;
>> > + } else {
>> > + IfTrue = Pred2;
>> > + IfFalse = Pred1;
>> > + }
>> > + return BI->getCondition();
>> > +}
>> >
>> > Modified: llvm/trunk/lib/Transforms/Utils/CMakeLists.txt
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CMakeLists.txt?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Utils/CMakeLists.txt (original)
>> > +++ llvm/trunk/lib/Transforms/Utils/CMakeLists.txt Mon Aug 5 21:43:45
>> > 2013
>> > @@ -25,6 +25,7 @@ add_llvm_library(LLVMTransformUtils
>> > PromoteMemoryToRegister.cpp
>> > SSAUpdater.cpp
>> > SimplifyCFG.cpp
>> > + FlattenCFG.cpp
>> > SimplifyIndVar.cpp
>> > SimplifyInstructions.cpp
>> > SimplifyLibCalls.cpp
>> >
>> > Added: llvm/trunk/lib/Transforms/Utils/FlattenCFG.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/FlattenCFG.cpp?rev=187764&view=auto
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Utils/FlattenCFG.cpp (added)
>> > +++ llvm/trunk/lib/Transforms/Utils/FlattenCFG.cpp Mon Aug 5 21:43:45
>> > 2013
>> > @@ -0,0 +1,487 @@
>> > +//===- FlatternCFG.cpp - Code to perform CFG flattening
>> > ---------------===//
>> > +//
>> > +// The LLVM Compiler Infrastructure
>> > +//
>> > +// This file is distributed under the University of Illinois Open
>> > Source
>> > +// License. See LICENSE.TXT for details.
>> > +//
>> >
>> > +//===----------------------------------------------------------------------===//
>> > +//
>> > +// Reduce conditional branches in CFG.
>> > +//
>> >
>> > +//===----------------------------------------------------------------------===//
>> > +
>> > +#define DEBUG_TYPE "flattencfg"
>> > +#include "llvm/Transforms/Utils/Local.h"
>> > +#include "llvm/ADT/SmallPtrSet.h"
>> > +#include "llvm/Analysis/AliasAnalysis.h"
>> > +#include "llvm/Analysis/ValueTracking.h"
>> > +#include "llvm/IR/IRBuilder.h"
>> > +#include "llvm/Support/Debug.h"
>> > +#include "llvm/Transforms/Utils/BasicBlockUtils.h"
>> > +using namespace llvm;
>> > +
>> > +namespace {
>> > +class FlattenCFGOpt {
>> > + AliasAnalysis *AA;
>> > + /// \brief Use parallel-and or parallel-or to generate conditions for
>> > + /// conditional branches.
>> > + bool FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder, Pass
>> > *P = 0);
>> > + /// \brief If \param BB is the merge block of an if-region, attempt
>> > to merge
>> > + /// the if-region with an adjacent if-region upstream if two
>> > if-regions
>> > + /// contain identical instructions.
>> > + bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder, Pass *P =
>> > 0);
>> > + /// \brief Compare a pair of blocks: \p Block1 and \p Block2, which
>> > + /// are from two if-regions whose entry blocks are \p Head1 and \p
>> > + /// Head2. \returns true if \p Block1 and \p Block2 contain
>> > identical
>> > + /// instructions, and have no memory reference alias with \p Head2.
>> > + /// This is used as a legality check for merging if-regions.
>> > + bool CompareIfRegionBlock(BasicBlock *Head1, BasicBlock *Head2,
>> > + BasicBlock *Block1, BasicBlock *Block2);
>> > +
>> > +public:
>> > + FlattenCFGOpt(AliasAnalysis *AA) : AA(AA) {}
>> > + bool run(BasicBlock *BB);
>> > +};
>> > +}
>> > +
>> > +/// If \param [in] BB has more than one predecessor that is a
>> > conditional
>> > +/// branch, attempt to use parallel and/or for the branch condition.
>> > \returns
>> > +/// true on success.
>> > +///
>> > +/// Before:
>> > +/// ......
>> > +/// %cmp10 = fcmp une float %tmp1, %tmp2
>> > +/// br i1 %cmp1, label %if.then, label %lor.rhs
>> > +///
>> > +/// lor.rhs:
>> > +/// ......
>> > +/// %cmp11 = fcmp une float %tmp3, %tmp4
>> > +/// br i1 %cmp11, label %if.then, label %ifend
>> > +///
>> > +/// if.end: // the merge block
>> > +/// ......
>> > +///
>> > +/// if.then: // has two predecessors, both of them contains conditional
>> > branch.
>> > +/// ......
>> > +/// br label %if.end;
>> > +///
>> > +/// After:
>> > +/// ......
>> > +/// %cmp10 = fcmp une float %tmp1, %tmp2
>> > +/// ......
>> > +/// %cmp11 = fcmp une float %tmp3, %tmp4
>> > +/// %cmp12 = or i1 %cmp10, %cmp11 // parallel-or mode.
>> > +/// br i1 %cmp12, label %if.then, label %ifend
>> > +///
>> > +/// if.end:
>> > +/// ......
>> > +///
>> > +/// if.then:
>> > +/// ......
>> > +/// br label %if.end;
>> > +///
>> > +/// Current implementation handles two cases.
>> > +/// Case 1: \param BB is on the else-path.
>> > +///
>> > +/// BB1
>> > +/// / |
>> > +/// BB2 |
>> > +/// / \ |
>> > +/// BB3 \ | where, BB1, BB2 contain conditional branches.
>> > +/// \ | / BB3 contains unconditional branch.
>> > +/// \ | / BB4 corresponds to \param BB which is also the
>> > merge.
>> > +/// BB => BB4
>> > +///
>> > +///
>> > +/// Corresponding source code:
>> > +///
>> > +/// if (a == b && c == d)
>> > +/// statement; // BB3
>> > +///
>> > +/// Case 2: \param BB BB is on the then-path.
>> > +///
>> > +/// BB1
>> > +/// / |
>> > +/// | BB2
>> > +/// \ / | where BB1, BB2 contain conditional branches.
>> > +/// BB => BB3 | BB3 contains unconditiona branch and
>> > corresponds
>> > +/// \ / to \param BB. BB4 is the merge.
>> > +/// BB4
>> > +///
>> > +/// Corresponding source code:
>> > +///
>> > +/// if (a == b || c == d)
>> > +/// statement; // BB3
>> > +///
>> > +/// In both cases, \param BB is the common successor of conditional
>> > branches.
>> > +/// In Case 1, \param BB (BB4) has an unconditional branch (BB3) as
>> > +/// its predecessor. In Case 2, \param BB (BB3) only has conditional
>> > branches
>> > +/// as its predecessors.
>> > +///
>> > +bool FlattenCFGOpt::FlattenParallelAndOr(BasicBlock *BB, IRBuilder<>
>> > &Builder,
>> > + Pass *P) {
>> > + PHINode *PHI = dyn_cast<PHINode>(BB->begin());
>> > + if (PHI)
>> > + return false; // For simplicity, avoid cases containing PHI nodes.
>> > +
>> > + BasicBlock *LastCondBlock = NULL;
>> > + BasicBlock *FirstCondBlock = NULL;
>> > + BasicBlock *UnCondBlock = NULL;
>> > + int Idx = -1;
>> > +
>> > + // Check predecessors of \param BB.
>> > + SmallPtrSet<BasicBlock *, 16> Preds(pred_begin(BB), pred_end(BB));
>> > + for (SmallPtrSetIterator<BasicBlock *> PI = Preds.begin(), PE =
>> > Preds.end();
>> > + PI != PE; ++PI) {
>> > + BasicBlock *Pred = *PI;
>> > + BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator());
>> > +
>> > + // All predecessors should terminate with a branch.
>> > + if (!PBI)
>> > + return false;
>> > +
>> > + BasicBlock *PP = Pred->getSinglePredecessor();
>> > +
>> > + if (PBI->isUnconditional()) {
>> > + // Case 1: Pred (BB3) is an unconditional block, it should
>> > + // have a single predecessor (BB2) that is also a predecessor
>> > + // of \param BB (BB4) and should not have address-taken.
>> > + // There should exist only one such unconditional
>> > + // branch among the predecessors.
>> > + if (UnCondBlock || !PP || (Preds.count(PP) == 0) ||
>> > + Pred->hasAddressTaken())
>> > + return false;
>> > +
>> > + UnCondBlock = Pred;
>> > + continue;
>> > + }
>> > +
>> > + // Only conditional branches are allowed beyond this point.
>> > + assert(PBI->isConditional());
>> > +
>> > + // Condition's unique use should be the branch instruction.
>> > + Value *PC = PBI->getCondition();
>> > + if (!PC || !PC->hasOneUse())
>> > + return false;
>> > +
>> > + if (PP && Preds.count(PP)) {
>> > + // These are internal condition blocks to be merged from, e.g.,
>> > + // BB2 in both cases.
>> > + // Should not be address-taken.
>> > + if (Pred->hasAddressTaken())
>> > + return false;
>> > +
>> > + // Instructions in the internal condition blocks should be safe
>> > + // to hoist up.
>> > + for (BasicBlock::iterator BI = Pred->begin(), BE = PBI; BI !=
>> > BE;) {
>> > + Instruction *CI = BI++;
>> > + if (isa<PHINode>(CI) || !isSafeToSpeculativelyExecute(CI))
>> > + return false;
>> > + }
>> > + } else {
>> > + // This is the condition block to be merged into, e.g. BB1 in
>> > + // both cases.
>> > + if (FirstCondBlock)
>> > + return false;
>> > + FirstCondBlock = Pred;
>> > + }
>> > +
>> > + // Find whether BB is uniformly on the true (or false) path
>> > + // for all of its predecessors.
>> > + BasicBlock *PS1 = PBI->getSuccessor(0);
>> > + BasicBlock *PS2 = PBI->getSuccessor(1);
>> > + BasicBlock *PS = (PS1 == BB) ? PS2 : PS1;
>> > + int CIdx = (PS1 == BB) ? 0 : 1;
>> > +
>> > + if (Idx == -1)
>> > + Idx = CIdx;
>> > + else if (CIdx != Idx)
>> > + return false;
>> > +
>> > + // PS is the successor which is not BB. Check successors to
>> > identify
>> > + // the last conditional branch.
>> > + if (Preds.count(PS) == 0) {
>> > + // Case 2.
>> > + LastCondBlock = Pred;
>> > + } else {
>> > + // Case 1
>> > + BranchInst *BPS = dyn_cast<BranchInst>(PS->getTerminator());
>> > + if (BPS && BPS->isUnconditional()) {
>> > + // Case 1: PS(BB3) should be an unconditional branch.
>> > + LastCondBlock = Pred;
>> > + }
>> > + }
>> > + }
>> > +
>> > + if (!FirstCondBlock || !LastCondBlock || (FirstCondBlock ==
>> > LastCondBlock))
>> > + return false;
>> > +
>> > + TerminatorInst *TBB = LastCondBlock->getTerminator();
>> > + BasicBlock *PS1 = TBB->getSuccessor(0);
>> > + BasicBlock *PS2 = TBB->getSuccessor(1);
>> > + BranchInst *PBI1 = dyn_cast<BranchInst>(PS1->getTerminator());
>> > + BranchInst *PBI2 = dyn_cast<BranchInst>(PS2->getTerminator());
>> > +
>> > + // If PS1 does not jump into PS2, but PS2 jumps into PS1,
>> > + // attempt branch inversion.
>> > + if (!PBI1 || !PBI1->isUnconditional() ||
>> > + (PS1->getTerminator()->getSuccessor(0) != PS2)) {
>> > + // Check whether PS2 jumps into PS1.
>> > + if (!PBI2 || !PBI2->isUnconditional() ||
>> > + (PS2->getTerminator()->getSuccessor(0) != PS1))
>> > + return false;
>> > +
>> > + // Do branch inversion.
>> > + BasicBlock *CurrBlock = LastCondBlock;
>> > + bool EverChanged = false;
>> > + while (1) {
>> > + BranchInst *BI =
>> > dyn_cast<BranchInst>(CurrBlock->getTerminator());
>> > + CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition());
>> > + CmpInst::Predicate Predicate = CI->getPredicate();
>> > + // Cannonicalize icmp_ne -> icmp_eq, fcmp_one -> fcmp_oeq
>> > + if ((Predicate == CmpInst::ICMP_NE) || (Predicate ==
>> > CmpInst::FCMP_ONE)) {
>> > + CI->setPredicate(ICmpInst::getInversePredicate(Predicate));
>> > + BI->swapSuccessors();
>> > + EverChanged = true;
>> > + }
>> > + if (CurrBlock == FirstCondBlock)
>> > + break;
>> > + CurrBlock = CurrBlock->getSinglePredecessor();
>> > + }
>> > + return EverChanged;
>> > + }
>> > +
>> > + // PS1 must have a conditional branch.
>> > + if (!PBI1 || !PBI1->isUnconditional())
>> > + return false;
>> > +
>> > + // PS2 should not contain PHI node.
>> > + PHI = dyn_cast<PHINode>(PS2->begin());
>> > + if (PHI)
>> > + return false;
>> > +
>> > + // Do the transformation.
>> > + BasicBlock *CB;
>> > + BranchInst *PBI =
>> > dyn_cast<BranchInst>(FirstCondBlock->getTerminator());
>> > + bool Iteration = true;
>> > + BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
>> > + BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
>> > + Value *PC = PBI->getCondition();
>> > +
>> > + do {
>> > + CB = PBI->getSuccessor(1 - Idx);
>> > + // Delete the conditional branch.
>> > + FirstCondBlock->getInstList().pop_back();
>> > + FirstCondBlock->getInstList()
>> > + .splice(FirstCondBlock->end(), CB->getInstList());
>> > + PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
>> > + Value *CC = PBI->getCondition();
>> > + // Merge conditions.
>> > + Builder.SetInsertPoint(PBI);
>> > + Value *NC;
>> > + if (Idx == 0)
>> > + // Case 2, use parallel or.
>> > + NC = Builder.CreateOr(PC, CC);
>> > + else
>> > + // Case 1, use parallel and.
>> > + NC = Builder.CreateAnd(PC, CC);
>> > +
>> > + PBI->replaceUsesOfWith(CC, NC);
>> > + PC = NC;
>> > + if (CB == LastCondBlock)
>> > + Iteration = false;
>> > + // Remove internal conditional branches.
>> > + CB->dropAllReferences();
>> > + // make CB unreachable and let downstream to delete the block.
>> > + new UnreachableInst(CB->getContext(), CB);
>> > + } while (Iteration);
>> > +
>> > + Builder.SetInsertPoint(SaveInsertBB, SaveInsertPt);
>> > + DEBUG(dbgs() << "Use parallel and/or in:\n" << *FirstCondBlock);
>> > + return true;
>> > +}
>> > +
>> > +/// Compare blocks from two if-regions, where \param Head1 is the entry
>> > of the
>> > +/// 1st if-region. \param Head2 is the entry of the 2nd if-region.
>> > \param
>> > +/// Block1 is a block in the 1st if-region to compare. \param Block2 is
>> > a block
>> > +// in the 2nd if-region to compare. \returns true if \param Block1
>> > and \param
>> > +/// Block2 have identical instructions and do not have memory reference
>> > alias
>> > +/// with \param Head2.
>> > +///
>> > +bool FlattenCFGOpt::CompareIfRegionBlock(BasicBlock *Head1, BasicBlock
>> > *Head2,
>> > + BasicBlock *Block1,
>> > + BasicBlock *Block2) {
>> > + TerminatorInst *PTI2 = Head2->getTerminator();
>> > + Instruction *PBI2 = Head2->begin();
>> > +
>> > + bool eq1 = (Block1 == Head1);
>> > + bool eq2 = (Block2 == Head2);
>> > + if (eq1 || eq2) {
>> > + // An empty then-path or else-path.
>> > + return (eq1 == eq2);
>> > + }
>> > +
>> > + // Check whether instructions in Block1 and Block2 are identical
>> > + // and do not alias with instructions in Head2.
>> > + BasicBlock::iterator iter1 = Block1->begin();
>> > + BasicBlock::iterator end1 = Block1->getTerminator();
>> > + BasicBlock::iterator iter2 = Block2->begin();
>> > + BasicBlock::iterator end2 = Block2->getTerminator();
>> > +
>> > + while (1) {
>> > + if (iter1 == end1) {
>> > + if (iter2 != end2)
>> > + return false;
>> > + break;
>> > + }
>> > +
>> > + if (!iter1->isIdenticalTo(iter2))
>> > + return false;
>> > +
>> > + // Illegal to remove instructions with side effects except
>> > + // non-volatile stores.
>> > + if (iter1->mayHaveSideEffects()) {
>> > + Instruction *CurI = &*iter1;
>> > + StoreInst *SI = dyn_cast<StoreInst>(CurI);
>> > + if (!SI || SI->isVolatile())
>> > + return false;
>> > + }
>> > +
>> > + // For simplicity and speed, data dependency check can be
>> > + // avoided if read from memory doesn't exist.
>> > + if (iter1->mayReadFromMemory())
>> > + return false;
>> > +
>> > + if (iter1->mayWriteToMemory()) {
>> > + for (BasicBlock::iterator BI = PBI2, BE = PTI2; BI != BE; ++BI) {
>> > + if (BI->mayReadFromMemory() || BI->mayWriteToMemory()) {
>> > + // Check alias with Head2.
>> > + if (!AA || AA->alias(iter1, BI))
>> > + return false;
>> > + }
>> > + }
>> > + }
>> > + ++iter1;
>> > + ++iter2;
>> > + }
>> > +
>> > + return true;
>> > +}
>> > +
>> > +/// Check whether \param BB is the merge block of a if-region. If yes,
>> > check
>> > +/// whether there exists an adjacent if-region upstream, the two
>> > if-regions
>> > +/// contain identical instuctions and can be legally merged. \returns
>> > true if
>> > +/// the two if-regions are merged.
>> > +///
>> > +/// From:
>> > +/// if (a)
>> > +/// statement;
>> > +/// if (b)
>> > +/// statement;
>> > +///
>> > +/// To:
>> > +/// if (a || b)
>> > +/// statement;
>> > +///
>> > +bool FlattenCFGOpt::MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder,
>> > + Pass *P) {
>> > + BasicBlock *IfTrue2, *IfFalse2;
>> > + Value *IfCond2 = GetIfCondition(BB, IfTrue2, IfFalse2);
>> > + Instruction *CInst2 = dyn_cast_or_null<Instruction>(IfCond2);
>> > + if (!CInst2)
>> > + return false;
>> > +
>> > + BasicBlock *SecondEntryBlock = CInst2->getParent();
>> > + if (SecondEntryBlock->hasAddressTaken())
>> > + return false;
>> > +
>> > + BasicBlock *IfTrue1, *IfFalse1;
>> > + Value *IfCond1 = GetIfCondition(SecondEntryBlock, IfTrue1, IfFalse1);
>> > + Instruction *CInst1 = dyn_cast_or_null<Instruction>(IfCond1);
>> > + if (!CInst1)
>> > + return false;
>> > +
>> > + BasicBlock *FirstEntryBlock = CInst1->getParent();
>> > +
>> > + // Either then-path or else-path should be empty.
>> > + if ((IfTrue1 != FirstEntryBlock) && (IfFalse1 != FirstEntryBlock))
>> > + return false;
>> > + if ((IfTrue2 != SecondEntryBlock) && (IfFalse2 != SecondEntryBlock))
>> > + return false;
>> > +
>> > + TerminatorInst *PTI2 = SecondEntryBlock->getTerminator();
>> > + Instruction *PBI2 = SecondEntryBlock->begin();
>> > +
>> > + if (!CompareIfRegionBlock(FirstEntryBlock, SecondEntryBlock, IfTrue1,
>> > + IfTrue2))
>> > + return false;
>> > +
>> > + if (!CompareIfRegionBlock(FirstEntryBlock, SecondEntryBlock,
>> > IfFalse1,
>> > + IfFalse2))
>> > + return false;
>> > +
>> > + // Check whether \param SecondEntryBlock has side-effect and is safe
>> > to
>> > + // speculate.
>> > + for (BasicBlock::iterator BI = PBI2, BE = PTI2; BI != BE; ++BI) {
>> > + Instruction *CI = BI;
>> > + if (isa<PHINode>(CI) || CI->mayHaveSideEffects() ||
>> > + !isSafeToSpeculativelyExecute(CI))
>> > + return false;
>> > + }
>> > +
>> > + // Merge \param SecondEntryBlock into \param FirstEntryBlock.
>> > + FirstEntryBlock->getInstList().pop_back();
>> > + FirstEntryBlock->getInstList()
>> > + .splice(FirstEntryBlock->end(), SecondEntryBlock->getInstList());
>> > + BranchInst *PBI =
>> > dyn_cast<BranchInst>(FirstEntryBlock->getTerminator());
>> > + Value *CC = PBI->getCondition();
>> > + BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
>> > + BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
>> > + Builder.SetInsertPoint(PBI);
>> > + Value *NC = Builder.CreateOr(CInst1, CC);
>> > + PBI->replaceUsesOfWith(CC, NC);
>> > + Builder.SetInsertPoint(SaveInsertBB, SaveInsertPt);
>> > +
>> > + // Remove IfTrue1
>> > + if (IfTrue1 != FirstEntryBlock) {
>> > + IfTrue1->dropAllReferences();
>> > + IfTrue1->eraseFromParent();
>> > + }
>> > +
>> > + // Remove IfFalse1
>> > + if (IfFalse1 != FirstEntryBlock) {
>> > + IfFalse1->dropAllReferences();
>> > + IfFalse1->eraseFromParent();
>> > + }
>> > +
>> > + // Remove \param SecondEntryBlock
>> > + SecondEntryBlock->dropAllReferences();
>> > + SecondEntryBlock->eraseFromParent();
>> > + DEBUG(dbgs() << "If conditions merged into:\n" << *FirstEntryBlock);
>> > + return true;
>> > +}
>> > +
>> > +bool FlattenCFGOpt::run(BasicBlock *BB) {
>> > + bool Changed = false;
>> > + assert(BB && BB->getParent() && "Block not embedded in function!");
>> > + assert(BB->getTerminator() && "Degenerate basic block encountered!");
>> > +
>> > + IRBuilder<> Builder(BB);
>> > +
>> > + if (FlattenParallelAndOr(BB, Builder))
>> > + return true;
>> > +
>> > + if (MergeIfRegion(BB, Builder))
>> > + return true;
>> > +
>> > + return Changed;
>> > +}
>> > +
>> > +/// FlattenCFG - This function is used to flatten a CFG. For
>> > +/// example, it uses parallel-and and parallel-or mode to collapse
>> > +// if-conditions and merge if-regions with identical statements.
>> > +///
>> > +bool llvm::FlattenCFG(BasicBlock *BB, AliasAnalysis *AA) {
>> > + return FlattenCFGOpt(AA).run(BB);
>> > +}
>> >
>> > Modified: llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp (original)
>> > +++ llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp Mon Aug 5 21:43:45
>> > 2013
>> > @@ -19,7 +19,6 @@
>> > #include "llvm/ADT/SmallPtrSet.h"
>> > #include "llvm/ADT/SmallVector.h"
>> > #include "llvm/ADT/Statistic.h"
>> > -#include "llvm/Analysis/AliasAnalysis.h"
>> > #include "llvm/Analysis/InstructionSimplify.h"
>> > #include "llvm/Analysis/TargetTransformInfo.h"
>> > #include "llvm/Analysis/ValueTracking.h"
>> > @@ -66,10 +65,6 @@ static cl::opt<bool>
>> > HoistCondStores("simplifycfg-hoist-cond-stores", cl::Hidden,
>> > cl::init(true),
>> > cl::desc("Hoist conditional stores if an unconditional store
>> > preceeds"));
>> >
>> > -static cl::opt<bool>
>> > -ParallelAndOr("simplifycfg-parallel-and-or", cl::Hidden,
>> > cl::init(true),
>> > - cl::desc("Use parallel-and-or mode for branch
>> > conditions"));
>> > -
>> > STATISTIC(NumBitMaps, "Number of switch instructions turned into
>> > bitmaps");
>> > STATISTIC(NumLookupTables, "Number of switch instructions turned into
>> > lookup tables");
>> > STATISTIC(NumSinkCommons, "Number of common instructions sunk down to
>> > the end block");
>> > @@ -95,8 +90,6 @@ namespace {
>> > class SimplifyCFGOpt {
>> > const TargetTransformInfo &TTI;
>> > const DataLayout *const TD;
>> > - AliasAnalysis *AA;
>> > -
>> > Value *isValueEqualityComparison(TerminatorInst *TI);
>> > BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI,
>> > std::vector<ValueEqualityComparisonCase>
>> > &Cases);
>> > @@ -113,25 +106,10 @@ class SimplifyCFGOpt {
>> > bool SimplifyIndirectBr(IndirectBrInst *IBI);
>> > bool SimplifyUncondBranch(BranchInst *BI, IRBuilder <> &Builder);
>> > bool SimplifyCondBranch(BranchInst *BI, IRBuilder <>&Builder);
>> > - /// \brief Use parallel-and or parallel-or to generate conditions for
>> > - /// conditional branches.
>> > - bool SimplifyParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder, Pass
>> > *P = 0);
>> > - /// \brief If \param BB is the merge block of an if-region, attempt
>> > to merge
>> > - /// the if-region with an adjacent if-region upstream if two
>> > if-regions
>> > - /// contain identical instructions.
>> > - bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder, Pass *P =
>> > 0);
>> > - /// \brief Compare a pair of blocks: \p Block1 and \p Block2, which
>> > - /// are from two if-regions whose entry blocks are \p Head1 and \p
>> > - /// Head2. \returns true if \p Block1 and \p Block2 contain
>> > identical
>> > - /// instructions, and have no memory reference alias with \p Head2.
>> > - /// This is used as a legality check for merging if-regions.
>> > - bool CompareIfRegionBlock(BasicBlock *Head1, BasicBlock *Head2,
>> > - BasicBlock *Block1, BasicBlock *Block2);
>> >
>> > public:
>> > - SimplifyCFGOpt(const TargetTransformInfo &TTI, const DataLayout *TD,
>> > - AliasAnalysis *AA)
>> > - : TTI(TTI), TD(TD), AA(AA) {}
>> > + SimplifyCFGOpt(const TargetTransformInfo &TTI, const DataLayout *TD)
>> > + : TTI(TTI), TD(TD) {}
>> > bool run(BasicBlock *BB);
>> > };
>> > }
>> > @@ -217,108 +195,6 @@ static void AddPredecessorToBlock(BasicB
>> > PN->addIncoming(PN->getIncomingValueForBlock(ExistPred), NewPred);
>> > }
>> >
>> > -
>> > -/// GetIfCondition - Given a basic block (BB) with two predecessors,
>> > -/// check to see if the merge at this block is due
>> > -/// to an "if condition". If so, return the boolean condition that
>> > determines
>> > -/// which entry into BB will be taken. Also, return by references the
>> > block
>> > -/// that will be entered from if the condition is true, and the block
>> > that will
>> > -/// be entered if the condition is false.
>> > -///
>> > -/// This does no checking to see if the true/false blocks have large or
>> > unsavory
>> > -/// instructions in them.
>> > -static Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue,
>> > - BasicBlock *&IfFalse) {
>> > - PHINode *SomePHI = dyn_cast<PHINode>(BB->begin());
>> > - BasicBlock *Pred1 = NULL;
>> > - BasicBlock *Pred2 = NULL;
>> > -
>> > - if (SomePHI) {
>> > - if (SomePHI->getNumIncomingValues() != 2)
>> > - return NULL;
>> > - Pred1 = SomePHI->getIncomingBlock(0);
>> > - Pred2 = SomePHI->getIncomingBlock(1);
>> > - } else {
>> > - pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
>> > - if (PI == PE) // No predecessor
>> > - return NULL;
>> > - Pred1 = *PI++;
>> > - if (PI == PE) // Only one predecessor
>> > - return NULL;
>> > - Pred2 = *PI++;
>> > - if (PI != PE) // More than two predecessors
>> > - return NULL;
>> > - }
>> > -
>> > - // We can only handle branches. Other control flow will be lowered
>> > to
>> > - // branches if possible anyway.
>> > - BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator());
>> > - BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator());
>> > - if (Pred1Br == 0 || Pred2Br == 0)
>> > - return 0;
>> > -
>> > - // Eliminate code duplication by ensuring that Pred1Br is conditional
>> > if
>> > - // either are.
>> > - if (Pred2Br->isConditional()) {
>> > - // If both branches are conditional, we don't have an "if
>> > statement". In
>> > - // reality, we could transform this case, but since the condition
>> > will be
>> > - // required anyway, we stand no chance of eliminating it, so the
>> > xform is
>> > - // probably not profitable.
>> > - if (Pred1Br->isConditional())
>> > - return 0;
>> > -
>> > - std::swap(Pred1, Pred2);
>> > - std::swap(Pred1Br, Pred2Br);
>> > - }
>> > -
>> > - if (Pred1Br->isConditional()) {
>> > - // The only thing we have to watch out for here is to make sure
>> > that Pred2
>> > - // doesn't have incoming edges from other blocks. If it does, the
>> > condition
>> > - // doesn't dominate BB.
>> > - if (Pred2->getSinglePredecessor() == 0)
>> > - return 0;
>> > -
>> > - // If we found a conditional branch predecessor, make sure that it
>> > branches
>> > - // to BB and Pred2Br. If it doesn't, this isn't an "if statement".
>> > - if (Pred1Br->getSuccessor(0) == BB &&
>> > - Pred1Br->getSuccessor(1) == Pred2) {
>> > - IfTrue = Pred1;
>> > - IfFalse = Pred2;
>> > - } else if (Pred1Br->getSuccessor(0) == Pred2 &&
>> > - Pred1Br->getSuccessor(1) == BB) {
>> > - IfTrue = Pred2;
>> > - IfFalse = Pred1;
>> > - } else {
>> > - // We know that one arm of the conditional goes to BB, so the
>> > other must
>> > - // go somewhere unrelated, and this must not be an "if
>> > statement".
>> > - return 0;
>> > - }
>> > -
>> > - return Pred1Br->getCondition();
>> > - }
>> > -
>> > - // Ok, if we got here, both predecessors end with an unconditional
>> > branch to
>> > - // BB. Don't panic! If both blocks only have a single (identical)
>> > - // predecessor, and THAT is a conditional branch, then we're all ok!
>> > - BasicBlock *CommonPred = Pred1->getSinglePredecessor();
>> > - if (CommonPred == 0 || CommonPred != Pred2->getSinglePredecessor())
>> > - return 0;
>> > -
>> > - // Otherwise, if this is a conditional branch, then we can use it!
>> > - BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator());
>> > - if (BI == 0) return 0;
>> > -
>> > - assert(BI->isConditional() && "Two successors but not conditional?");
>> > - if (BI->getSuccessor(0) == Pred1) {
>> > - IfTrue = Pred1;
>> > - IfFalse = Pred2;
>> > - } else {
>> > - IfTrue = Pred2;
>> > - IfFalse = Pred1;
>> > - }
>> > - return BI->getCondition();
>> > -}
>> > -
>> > /// ComputeSpeculationCost - Compute an abstract "cost" of speculating
>> > the
>> > /// given instruction, which is assumed to be safe to speculate. 1
>> > means
>> > /// cheap, 2 means less cheap, and UINT_MAX means prohibitively
>> > expensive.
>> > @@ -4102,386 +3978,6 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
>> > return false;
>> > }
>> >
>> > -/// If \param [in] BB has more than one predecessor that is a
>> > conditional
>> > -/// branch, attempt to use parallel and/or for the branch condition.
>> > \returns
>> > -/// true on success.
>> > -///
>> > -/// Before:
>> > -/// ......
>> > -/// %cmp10 = fcmp une float %tmp1, %tmp2
>> > -/// br i1 %cmp1, label %if.then, label %lor.rhs
>> > -///
>> > -/// lor.rhs:
>> > -/// ......
>> > -/// %cmp11 = fcmp une float %tmp3, %tmp4
>> > -/// br i1 %cmp11, label %if.then, label %ifend
>> > -///
>> > -/// if.end: // the merge block
>> > -/// ......
>> > -///
>> > -/// if.then: // has two predecessors, both of them contains conditional
>> > branch.
>> > -/// ......
>> > -/// br label %if.end;
>> > -///
>> > -/// After:
>> > -/// ......
>> > -/// %cmp10 = fcmp une float %tmp1, %tmp2
>> > -/// ......
>> > -/// %cmp11 = fcmp une float %tmp3, %tmp4
>> > -/// %cmp12 = or i1 %cmp10, %cmp11 // parallel-or mode.
>> > -/// br i1 %cmp12, label %if.then, label %ifend
>> > -///
>> > -/// if.end:
>> > -/// ......
>> > -///
>> > -/// if.then:
>> > -/// ......
>> > -/// br label %if.end;
>> > -///
>> > -/// Current implementation handles two cases.
>> > -/// Case 1: \param BB is on the else-path.
>> > -///
>> > -/// BB1
>> > -/// / |
>> > -/// BB2 |
>> > -/// / \ |
>> > -/// BB3 \ | where, BB1, BB2 contain conditional branches.
>> > -/// \ | / BB3 contains unconditional branch.
>> > -/// \ | / BB4 corresponds to \param BB which is also the
>> > merge.
>> > -/// BB => BB4
>> > -///
>> > -///
>> > -/// Corresponding source code:
>> > -///
>> > -/// if (a == b && c == d)
>> > -/// statement; // BB3
>> > -///
>> > -/// Case 2: \param BB BB is on the then-path.
>> > -///
>> > -/// BB1
>> > -/// / |
>> > -/// | BB2
>> > -/// \ / | where BB1, BB2 contain conditional branches.
>> > -/// BB => BB3 | BB3 contains unconditiona branch and
>> > corresponds
>> > -/// \ / to \param BB. BB4 is the merge.
>> > -/// BB4
>> > -///
>> > -/// Corresponding source code:
>> > -///
>> > -/// if (a == b || c == d)
>> > -/// statement; // BB3
>> > -///
>> > -/// In both cases, \param BB is the common successor of conditional
>> > branches.
>> > -/// In Case 1, \param BB (BB4) has an unconditional branch (BB3) as
>> > -/// its predecessor. In Case 2, \param BB (BB3) only has conditional
>> > branches
>> > -/// as its predecessors.
>> > -///
>> > -bool SimplifyCFGOpt::SimplifyParallelAndOr(BasicBlock *BB, IRBuilder<>
>> > &Builder,
>> > - Pass *P) {
>> > - PHINode *PHI = dyn_cast<PHINode>(BB->begin());
>> > - if (PHI)
>> > - return false; // For simplicity, avoid cases containing PHI nodes.
>> > -
>> > - BasicBlock *LastCondBlock = NULL;
>> > - BasicBlock *FirstCondBlock = NULL;
>> > - BasicBlock *UnCondBlock = NULL;
>> > - int Idx = -1;
>> > -
>> > - // Check predecessors of \param BB.
>> > - SmallPtrSet<BasicBlock*, 16> Preds(pred_begin(BB), pred_end(BB));
>> > - for (SmallPtrSetIterator<BasicBlock*> PI = Preds.begin(), PE =
>> > Preds.end();
>> > - PI != PE; ++PI) {
>> > - BasicBlock *Pred = *PI;
>> > - BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator());
>> > -
>> > - // All predecessors should terminate with a branch.
>> > - if (!PBI)
>> > - return false;
>> > -
>> > - BasicBlock *PP = Pred->getSinglePredecessor();
>> > -
>> > - if (PBI->isUnconditional()) {
>> > - // Case 1: Pred (BB3) is an unconditional block, it should
>> > - // have a single predecessor (BB2) that is also a predecessor
>> > - // of \param BB (BB4) and should not have address-taken.
>> > - // There should exist only one such unconditional
>> > - // branch among the predecessors.
>> > - if (UnCondBlock || !PP || (Preds.count(PP) == 0) ||
>> > - Pred->hasAddressTaken())
>> > - return false;
>> > -
>> > - UnCondBlock = Pred;
>> > - continue;
>> > - }
>> > -
>> > - // Only conditional branches are allowed beyond this point.
>> > - assert(PBI->isConditional());
>> > -
>> > - // Condition's unique use should be the branch instruction.
>> > - Value *PC = PBI->getCondition();
>> > - if (!PC || !PC->hasOneUse())
>> > - return false;
>> > -
>> > - if (PP && Preds.count(PP)) {
>> > - // These are internal condition blocks to be merged from, e.g.,
>> > - // BB2 in both cases.
>> > - // Should not be address-taken.
>> > - if (Pred->hasAddressTaken())
>> > - return false;
>> > -
>> > - // Instructions in the internal condition blocks should be safe
>> > - // to hoist up.
>> > - for (BasicBlock::iterator BI = Pred->begin(), BE = PBI; BI !=
>> > BE;) {
>> > - Instruction *CI = BI++;
>> > - if (isa<PHINode>(CI) ||
>> > - !isSafeToSpeculativelyExecute(CI))
>> > - return false;
>> > - }
>> > - } else {
>> > - // This is the condition block to be merged into, e.g. BB1 in
>> > - // both cases.
>> > - if (FirstCondBlock)
>> > - return false;
>> > - FirstCondBlock = Pred;
>> > - }
>> > -
>> > - // Find whether BB is uniformly on the true (or false) path
>> > - // for all of its predecessors.
>> > - BasicBlock *PS1 = PBI->getSuccessor(0);
>> > - BasicBlock *PS2 = PBI->getSuccessor(1);
>> > - BasicBlock *PS = (PS1 == BB) ? PS2 : PS1;
>> > - int CIdx = (PS1 == BB) ? 0 : 1;
>> > -
>> > - if (Idx == -1)
>> > - Idx = CIdx;
>> > - else if (CIdx != Idx)
>> > - return false;
>> > -
>> > - // PS is the successor which is not BB. Check successors to
>> > identify
>> > - // the last conditional branch.
>> > - if (Preds.count(PS) == 0) {
>> > - // Case 2.
>> > - // BB must have an unique successor.
>> > - TerminatorInst *TBB = BB->getTerminator();
>> > - if (TBB->getNumSuccessors() != 1)
>> > - return false;
>> > -
>> > - BasicBlock *SBB = TBB->getSuccessor(0);
>> > - PHI = dyn_cast<PHINode>(SBB->begin());
>> > - if (PHI)
>> > - return false;
>> > -
>> > - // PS (BB4) should be BB's successor.
>> > - if (SBB != PS)
>> > - return false;
>> > - LastCondBlock = Pred;
>> > - } else {
>> > - BranchInst *BPS = dyn_cast<BranchInst>(PS->getTerminator());
>> > - if (BPS && BPS->isUnconditional()) {
>> > - // Case 1: PS(BB3) should be an unconditional branch.
>> > - LastCondBlock = Pred;
>> > - }
>> > - }
>> > - }
>> > -
>> > - if (!FirstCondBlock || !LastCondBlock || (FirstCondBlock ==
>> > LastCondBlock))
>> > - return false;
>> > -
>> > - // Do the transformation.
>> > - BasicBlock *CB;
>> > - bool Iteration = true;
>> > - BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
>> > - BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
>> > - BranchInst *PBI =
>> > dyn_cast<BranchInst>(FirstCondBlock->getTerminator());
>> > - Value *PC = PBI->getCondition();
>> > - do {
>> > - CB = PBI->getSuccessor(1 - Idx);
>> > - // Delete the conditional branch.
>> > - FirstCondBlock->getInstList().pop_back();
>> > - FirstCondBlock->getInstList().splice(FirstCondBlock->end(),
>> > CB->getInstList());
>> > - PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
>> > - Value *CC = PBI->getCondition();
>> > - // Merge conditions.
>> > - Builder.SetInsertPoint(PBI);
>> > - Value *NC;
>> > - if (Idx == 0)
>> > - // Case 2, use parallel or.
>> > - NC = Builder.CreateOr(PC, CC);
>> > - else
>> > - // Case 1, use parallel and.
>> > - NC = Builder.CreateAnd(PC, CC);
>> > -
>> > - PBI->replaceUsesOfWith(CC, NC);
>> > - PC = NC;
>> > - if (CB == LastCondBlock)
>> > - Iteration = false;
>> > - // Remove internal conditional branches.
>> > - CB->dropAllReferences();
>> > - // make CB unreachable and let downstream to delete the block.
>> > - new UnreachableInst(CB->getContext(), CB);
>> > - } while (Iteration);
>> > - if (SaveInsertBB)
>> > - Builder.SetInsertPoint(SaveInsertBB, SaveInsertPt);
>> > - DEBUG(dbgs() << "Use parallel and/or in:\n" << *FirstCondBlock);
>> > - return true;
>> > -}
>> > -
>> > -/// Compare blocks from two if-regions, where \param Head1 is the entry
>> > of the
>> > -/// 1st if-region. \param Head2 is the entry of the 2nd if-region.
>> > \param
>> > -/// Block1 is a block in the 1st if-region to compare. \param Block2 is
>> > a block
>> > -// in the 2nd if-region to compare. \returns true if \param Block1
>> > and \param
>> > -/// Block2 have identical instructions and do not have memory reference
>> > alias
>> > -/// with \param Head2.
>> > -///
>> > -bool SimplifyCFGOpt::CompareIfRegionBlock(BasicBlock *Head1, BasicBlock
>> > *Head2,
>> > - BasicBlock *Block1,
>> > BasicBlock *Block2) {
>> > - TerminatorInst *PTI2 = Head2->getTerminator();
>> > - Instruction *PBI2 = Head2->begin();
>> > -
>> > - bool eq1 = (Block1 == Head1);
>> > - bool eq2 = (Block2 == Head2);
>> > - if (eq1 || eq2) {
>> > - // An empty then-path or else-path.
>> > - return (eq1 == eq2);
>> > - }
>> > -
>> > - // Check whether instructions in Block1 and Block2 are identical
>> > - // and do not alias with instructions in Head2.
>> > - BasicBlock::iterator iter1 = Block1->begin();
>> > - BasicBlock::iterator end1 = Block1->getTerminator();
>> > - BasicBlock::iterator iter2 = Block2->begin();
>> > - BasicBlock::iterator end2 = Block2->getTerminator();
>> > -
>> > - while (1) {
>> > - if (iter1 == end1) {
>> > - if (iter2 != end2)
>> > - return false;
>> > - break;
>> > - }
>> > -
>> > - if (!iter1->isIdenticalTo(iter2))
>> > - return false;
>> > -
>> > - // Illegal to remove instructions with side effects except
>> > - // non-volatile stores.
>> > - if (iter1->mayHaveSideEffects()) {
>> > - Instruction *CurI = &*iter1;
>> > - StoreInst *SI = dyn_cast<StoreInst>(CurI);
>> > - if (!SI || SI->isVolatile())
>> > - return false;
>> > - }
>> > -
>> > - // For simplicity and speed, data dependency check can be
>> > - // avoided if read from memory doesn't exist.
>> > - if (iter1->mayReadFromMemory())
>> > - return false;
>> > -
>> > - if (iter1->mayWriteToMemory()) {
>> > - for (BasicBlock::iterator BI = PBI2, BE = PTI2; BI != BE; ++BI) {
>> > - if (BI->mayReadFromMemory() || BI->mayWriteToMemory()) {
>> > - // Check alias with Head2.
>> > - if (!AA || AA->alias(iter1, BI))
>> > - return false;
>> > - }
>> > - }
>> > - }
>> > - ++iter1;
>> > - ++iter2;
>> > - }
>> > -
>> > - return true;
>> > -}
>> > -
>> > -/// Check whether \param BB is the merge block of a if-region. If yes,
>> > check
>> > -/// whether there exists an adjacent if-region upstream, the two
>> > if-regions
>> > -/// contain identical instuctions and can be legally merged. \returns
>> > true if
>> > -/// the two if-regions are merged.
>> > -///
>> > -/// From:
>> > -/// if (a)
>> > -/// statement;
>> > -/// if (b)
>> > -/// statement;
>> > -///
>> > -/// To:
>> > -/// if (a || b)
>> > -/// statement;
>> > -///
>> > -bool SimplifyCFGOpt::MergeIfRegion(BasicBlock *BB, IRBuilder<>
>> > &Builder,
>> > - Pass *P) {
>> > - BasicBlock *IfTrue2, *IfFalse2;
>> > - Value *IfCond2 = GetIfCondition(BB, IfTrue2, IfFalse2);
>> > - Instruction *CInst2 = dyn_cast_or_null<Instruction>(IfCond2);
>> > - if (!CInst2)
>> > - return false;
>> > -
>> > - BasicBlock *SecondEntryBlock = CInst2->getParent();
>> > - if (SecondEntryBlock->hasAddressTaken())
>> > - return false;
>> > -
>> > - BasicBlock *IfTrue1, *IfFalse1;
>> > - Value *IfCond1 = GetIfCondition(SecondEntryBlock, IfTrue1, IfFalse1);
>> > - Instruction *CInst1 = dyn_cast_or_null<Instruction>(IfCond1);
>> > - if (!CInst1)
>> > - return false;
>> > -
>> > - BasicBlock *FirstEntryBlock = CInst1->getParent();
>> > -
>> > - // Either then-path or else-path should be empty.
>> > - if ((IfTrue1 != FirstEntryBlock) && (IfFalse1 != FirstEntryBlock))
>> > - return false;
>> > - if ((IfTrue2 != SecondEntryBlock) && (IfFalse2 != SecondEntryBlock))
>> > - return false;
>> > -
>> > - TerminatorInst *PTI2 = SecondEntryBlock->getTerminator();
>> > - Instruction *PBI2 = SecondEntryBlock->begin();
>> > -
>> > - if (!CompareIfRegionBlock(FirstEntryBlock, SecondEntryBlock, IfTrue1,
>> > IfTrue2))
>> > - return false;
>> > -
>> > - if (!CompareIfRegionBlock(FirstEntryBlock, SecondEntryBlock,
>> > IfFalse1, IfFalse2))
>> > - return false;
>> > -
>> > - // Check whether \param SecondEntryBlock has side-effect and is safe
>> > to speculate.
>> > - for (BasicBlock::iterator BI = PBI2, BE = PTI2; BI != BE; ++BI) {
>> > - Instruction *CI = BI;
>> > - if (isa<PHINode>(CI) || CI->mayHaveSideEffects() ||
>> > - !isSafeToSpeculativelyExecute(CI))
>> > - return false;
>> > - }
>> > -
>> > - // Merge \param SecondEntryBlock into \param FirstEntryBlock.
>> > - FirstEntryBlock->getInstList().pop_back();
>> > - FirstEntryBlock->getInstList().splice(FirstEntryBlock->end(),
>> > SecondEntryBlock->getInstList());
>> > - BranchInst *PBI =
>> > dyn_cast<BranchInst>(FirstEntryBlock->getTerminator());
>> > - Value *CC = PBI->getCondition();
>> > - BasicBlock *SaveInsertBB = Builder.GetInsertBlock();
>> > - BasicBlock::iterator SaveInsertPt = Builder.GetInsertPoint();
>> > - Builder.SetInsertPoint(PBI);
>> > - Value *NC = Builder.CreateOr(CInst1, CC);
>> > - PBI->replaceUsesOfWith(CC, NC);
>> > - if (SaveInsertBB)
>> > - Builder.SetInsertPoint(SaveInsertBB, SaveInsertPt);
>> > -
>> > - // Remove IfTrue1
>> > - if (IfTrue1 != FirstEntryBlock) {
>> > - IfTrue1->dropAllReferences();
>> > - IfTrue1->eraseFromParent();
>> > - }
>> > -
>> > - // Remove IfFalse1
>> > - if (IfFalse1 != FirstEntryBlock) {
>> > - IfFalse1->dropAllReferences();
>> > - IfFalse1->eraseFromParent();
>> > - }
>> > -
>> > - // Remove \param SecondEntryBlock
>> > - SecondEntryBlock->dropAllReferences();
>> > - SecondEntryBlock->eraseFromParent();
>> > - DEBUG(dbgs() << "If conditions merged into:\n" << *FirstEntryBlock);
>> > - return true;
>> > -}
>> > -
>> > /// Check if passing a value to an instruction will cause undefined
>> > behavior.
>> > static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I) {
>> > Constant *C = dyn_cast<Constant>(V);
>> > @@ -4584,11 +4080,6 @@ bool SimplifyCFGOpt::run(BasicBlock *BB)
>> > return true;
>> >
>> > IRBuilder<> Builder(BB);
>> > - // Whether to optimize conditional branches.
>> > - bool OptCB = (ParallelAndOr && AA && TTI.hasBranchDivergence());
>> > -
>> > - if (OptCB && SimplifyParallelAndOr(BB, Builder))
>> > - return true;
>> >
>> > // If there is a trivial two-entry PHI node in this basic block, and
>> > we can
>> > // eliminate it, do so now.
>> > @@ -4617,9 +4108,6 @@ bool SimplifyCFGOpt::run(BasicBlock *BB)
>> > if (SimplifyIndirectBr(IBI)) return true;
>> > }
>> >
>> > - if (OptCB && MergeIfRegion(BB, Builder))
>> > - return true;
>> > -
>> > return Changed;
>> > }
>> >
>> > @@ -4629,6 +4117,6 @@ bool SimplifyCFGOpt::run(BasicBlock *BB)
>> > /// of the CFG. It returns true if a modification was made.
>> > ///
>> > bool llvm::SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
>> > - const DataLayout *TD, AliasAnalysis *AA) {
>> > - return SimplifyCFGOpt(TTI, TD, AA).run(BB);
>> > + const DataLayout *TD) {
>> > + return SimplifyCFGOpt(TTI, TD).run(BB);
>> > }
>> >
>> > Copied: llvm/trunk/test/CodeGen/R600/parallelandifcollapse.ll (from
>> > r187754,
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll)
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/R600/parallelandifcollapse.ll?p2=llvm/trunk/test/CodeGen/R600/parallelandifcollapse.ll&p1=llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll&r1=187754&r2=187764&rev=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > (original)
>> > +++ llvm/trunk/test/CodeGen/R600/parallelandifcollapse.ll Mon Aug 5
>> > 21:43:45 2013
>> > @@ -1,14 +1,12 @@
>> > ; Function Attrs: nounwind
>> > -; RUN: opt < %s -mtriple=r600-unknown-linux-gnu -optimizecfg -basicaa
>> > -S | FileCheck %s
>> > +; RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck %s
>> > ;
>> > -; CFG optimization should use parallel-or mode to generate branch
>> > conditions and
>> > -; then merge if-regions with the same bodies, which should result in 2
>> > branches.
>> > -; To see the assembly output without this transformation, remove
>> > -basicaa option.
>> > +; CFG flattening should use parallel-and mode to generate branch
>> > conditions and
>> > +; then merge if-regions with the same bodies.
>> > ;
>> > -; CHECK: or i1
>> > -; CHECK-NEXT: br
>> > -; CHECK: br
>> > -; CHECK: ret
>> > +; CHECK: AND_INT
>> > +; CHECK-NEXT: AND_INT
>> > +; CHECK-NEXT: OR_INT
>> > define void @_Z9chk1D_512v() #0 {
>> > entry:
>> > %a0 = alloca i32, align 4
>> >
>> > Copied: llvm/trunk/test/CodeGen/R600/parallelorifcollapse.ll (from
>> > r187754,
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll)
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/R600/parallelorifcollapse.ll?p2=llvm/trunk/test/CodeGen/R600/parallelorifcollapse.ll&p1=llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll&r1=187754&r2=187764&rev=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > (original)
>> > +++ llvm/trunk/test/CodeGen/R600/parallelorifcollapse.ll Mon Aug 5
>> > 21:43:45 2013
>> > @@ -1,14 +1,12 @@
>> > ; Function Attrs: nounwind
>> > -; RUN: opt < %s -mtriple=r600-unknown-linux-gnu -optimizecfg -basicaa
>> > -S | FileCheck %s
>> > +; RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck %s
>> > ;
>> > -; CFG optimization should use parallel-and mode to generate branch
>> > conditions and
>> > -; then merge if-regions with the same bodies, which should result in 2
>> > branches.
>> > -; To see the assembly output without this transformation, remove
>> > -basicaa option.
>> > -;
>> > -; CHECK: or i1
>> > -; CHECK-NEXT: br
>> > -; CHECK: br
>> > -; CHECK: ret
>> > +; CFG flattening should use parallel-or to generate branch conditions
>> > and
>> > +; then merge if-regions with the same bodies.
>> > +;
>> > +; CHECK: OR_INT
>> > +; CHECK-NEXT: OR_INT
>> > +; CHECK-NEXT: OR_INT
>> > define void @_Z9chk1D_512v() #0 {
>> > entry:
>> > %a0 = alloca i32, align 4
>> >
>> > Modified: llvm/trunk/test/Transforms/SimplifyCFG/R600/lit.local.cfg
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/R600/lit.local.cfg?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/R600/lit.local.cfg (original)
>> > +++ llvm/trunk/test/Transforms/SimplifyCFG/R600/lit.local.cfg Mon Aug 5
>> > 21:43:45 2013
>> > @@ -1,6 +0,0 @@
>> > -config.suffixes = ['.ll', '.c', '.cpp']
>> > -
>> > -targets = set(config.root.targets_to_build.split())
>> > -if not 'R600' in targets:
>> > - config.unsupported = True
>> > -
>> >
>> > Modified:
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > (original)
>> > +++ llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelandifcollapse.ll
>> > Mon Aug 5 21:43:45 2013
>> > @@ -1,63 +0,0 @@
>> > -; Function Attrs: nounwind
>> > -; RUN: opt < %s -mtriple=r600-unknown-linux-gnu -optimizecfg -basicaa
>> > -S | FileCheck %s
>> > -;
>> > -; CFG optimization should use parallel-and mode to generate branch
>> > conditions and
>> > -; then merge if-regions with the same bodies, which should result in 2
>> > branches.
>> > -; To see the assembly output without this transformation, remove
>> > -basicaa option.
>> > -;
>> > -; CHECK: or i1
>> > -; CHECK-NEXT: br
>> > -; CHECK: br
>> > -; CHECK: ret
>> > -define void @_Z9chk1D_512v() #0 {
>> > -entry:
>> > - %a0 = alloca i32, align 4
>> > - %b0 = alloca i32, align 4
>> > - %c0 = alloca i32, align 4
>> > - %d0 = alloca i32, align 4
>> > - %a1 = alloca i32, align 4
>> > - %b1 = alloca i32, align 4
>> > - %c1 = alloca i32, align 4
>> > - %d1 = alloca i32, align 4
>> > - %data = alloca i32, align 4
>> > - %0 = load i32* %a0, align 4
>> > - %1 = load i32* %b0, align 4
>> > - %cmp = icmp ne i32 %0, %1
>> > - br i1 %cmp, label %land.lhs.true, label %if.else
>> > -
>> > -land.lhs.true: ; preds = %entry
>> > - %2 = load i32* %c0, align 4
>> > - %3 = load i32* %d0, align 4
>> > - %cmp1 = icmp ne i32 %2, %3
>> > - br i1 %cmp1, label %if.then, label %if.else
>> > -
>> > -if.then: ; preds =
>> > %land.lhs.true
>> > - br label %if.end
>> > -
>> > -if.else: ; preds =
>> > %land.lhs.true, %entry
>> > - store i32 1, i32* %data, align 4
>> > - br label %if.end
>> > -
>> > -if.end: ; preds = %if.else,
>> > %if.then
>> > - %4 = load i32* %a1, align 4
>> > - %5 = load i32* %b1, align 4
>> > - %cmp2 = icmp ne i32 %4, %5
>> > - br i1 %cmp2, label %land.lhs.true3, label %if.else6
>> > -
>> > -land.lhs.true3: ; preds = %if.end
>> > - %6 = load i32* %c1, align 4
>> > - %7 = load i32* %d1, align 4
>> > - %cmp4 = icmp ne i32 %6, %7
>> > - br i1 %cmp4, label %if.then5, label %if.else6
>> > -
>> > -if.then5: ; preds =
>> > %land.lhs.true3
>> > - br label %if.end7
>> > -
>> > -if.else6: ; preds =
>> > %land.lhs.true3, %if.end
>> > - store i32 1, i32* %data, align 4
>> > - br label %if.end7
>> > -
>> > -if.end7: ; preds = %if.else6,
>> > %if.then5
>> > - ret void
>> > -}
>> > -
>> >
>> > Modified:
>> > llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > (original)
>> > +++ llvm/trunk/test/Transforms/SimplifyCFG/R600/parallelorifcollapse.ll
>> > Mon Aug 5 21:43:45 2013
>> > @@ -1,56 +0,0 @@
>> > -; Function Attrs: nounwind
>> > -; RUN: opt < %s -mtriple=r600-unknown-linux-gnu -optimizecfg -basicaa
>> > -S | FileCheck %s
>> > -;
>> > -; CFG optimization should use parallel-or mode to generate branch
>> > conditions and
>> > -; then merge if-regions with the same bodies, which should result in 2
>> > branches.
>> > -; To see the assembly output without this transformation, remove
>> > -basicaa option.
>> > -;
>> > -; CHECK: or i1
>> > -; CHECK-NEXT: br
>> > -; CHECK: br
>> > -; CHECK: ret
>> > -define void @_Z9chk1D_512v() #0 {
>> > -entry:
>> > - %a0 = alloca i32, align 4
>> > - %b0 = alloca i32, align 4
>> > - %c0 = alloca i32, align 4
>> > - %d0 = alloca i32, align 4
>> > - %a1 = alloca i32, align 4
>> > - %b1 = alloca i32, align 4
>> > - %c1 = alloca i32, align 4
>> > - %d1 = alloca i32, align 4
>> > - %data = alloca i32, align 4
>> > - %0 = load i32* %a0, align 4
>> > - %1 = load i32* %b0, align 4
>> > - %cmp = icmp ne i32 %0, %1
>> > - br i1 %cmp, label %land.lhs.true, label %if.end
>> > -
>> > -land.lhs.true: ; preds = %entry
>> > - %2 = load i32* %c0, align 4
>> > - %3 = load i32* %d0, align 4
>> > - %cmp1 = icmp ne i32 %2, %3
>> > - br i1 %cmp1, label %if.then, label %if.end
>> > -
>> > -if.then: ; preds =
>> > %land.lhs.true
>> > - store i32 1, i32* %data, align 4
>> > - br label %if.end
>> > -
>> > -if.end: ; preds = %if.then,
>> > %land.lhs.true, %entry
>> > - %4 = load i32* %a1, align 4
>> > - %5 = load i32* %b1, align 4
>> > - %cmp2 = icmp ne i32 %4, %5
>> > - br i1 %cmp2, label %land.lhs.true3, label %if.end6
>> > -
>> > -land.lhs.true3: ; preds = %if.end
>> > - %6 = load i32* %c1, align 4
>> > - %7 = load i32* %d1, align 4
>> > - %cmp4 = icmp ne i32 %6, %7
>> > - br i1 %cmp4, label %if.then5, label %if.end6
>> > -
>> > -if.then5: ; preds =
>> > %land.lhs.true3
>> > - store i32 1, i32* %data, align 4
>> > - br label %if.end6
>> > -
>> > -if.end6: ; preds = %if.then5,
>> > %land.lhs.true3, %if.end
>> > - ret void
>> > -}
>> >
>> > Modified: llvm/trunk/test/Transforms/SimplifyCFG/lit.local.cfg
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/lit.local.cfg?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/test/Transforms/SimplifyCFG/lit.local.cfg (original)
>> > +++ llvm/trunk/test/Transforms/SimplifyCFG/lit.local.cfg Mon Aug 5
>> > 21:43:45 2013
>> > @@ -1 +0,0 @@
>> > -config.suffixes = ['.ll', '.c', '.cpp']
>> >
>> > Modified: llvm/trunk/tools/lto/LTOCodeGenerator.cpp
>> > URL:
>> > http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/lto/LTOCodeGenerator.cpp?rev=187764&r1=187763&r2=187764&view=diff
>> >
>> > ==============================================================================
>> > --- llvm/trunk/tools/lto/LTOCodeGenerator.cpp (original)
>> > +++ llvm/trunk/tools/lto/LTOCodeGenerator.cpp Mon Aug 5 21:43:45 2013
>> > @@ -118,7 +118,7 @@ void LTOCodeGenerator::initializeLTOPass
>> > initializeGVNPass(R);
>> > initializeMemCpyOptPass(R);
>> > initializeDCEPass(R);
>> > - initializeCFGCanonicalizePass(R);
>> > + initializeCFGSimplifyPassPass(R);
>> > }
>> >
>> > bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg) {
>> >
>> >
>> > _______________________________________________
>> > llvm-commits mailing list
>> > llvm-commits at cs.uiuc.edu
>> > http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
>
>
>
> --
> Thanks,
> --Serge
More information about the llvm-commits
mailing list