[llvm] r272607 - Bring back "[PM] Port JumpThreading to the new PM" with a fix

Richard Smith via llvm-commits llvm-commits at lists.llvm.org
Mon Jun 13 18:38:18 PDT 2016


Fixed in r272612, can you take a look and see if that's the right fix?

On Mon, Jun 13, 2016 at 6:27 PM, Richard Smith <richard at metafoo.co.uk>
wrote:

> This breaks the modules bot (as did the previous commit of this). Looks
> like BlockFrequencyInfo.h triggers an instantiation that requires a
> definition of BlockFrequencyInfoImpl.
>
> On Mon, Jun 13, 2016 at 5:51 PM, Sean Silva via llvm-commits <
> llvm-commits at lists.llvm.org> wrote:
>
>> Author: silvas
>> Date: Mon Jun 13 19:51:09 2016
>> New Revision: 272607
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=272607&view=rev
>> Log:
>> Bring back "[PM] Port JumpThreading to the new PM" with a fix
>>
>> This reverts commit r272603 and adds a fix.
>>
>> Big thanks to Davide for pointing me at r216244 which gives some insight
>> into how to fix this VS2013 issue. VS2013 can't synthesize a move
>> constructor. So the fix here is to add one explicitly to the
>> JumpThreadingPass class.
>>
>> Added:
>>     llvm/trunk/include/llvm/Transforms/Scalar/JumpThreading.h
>> Modified:
>>     llvm/trunk/lib/Passes/PassBuilder.cpp
>>     llvm/trunk/lib/Passes/PassRegistry.def
>>     llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
>>     llvm/trunk/test/Transforms/JumpThreading/thread-loads.ll
>>
>> Added: llvm/trunk/include/llvm/Transforms/Scalar/JumpThreading.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Scalar/JumpThreading.h?rev=272607&view=auto
>>
>> ==============================================================================
>> --- llvm/trunk/include/llvm/Transforms/Scalar/JumpThreading.h (added)
>> +++ llvm/trunk/include/llvm/Transforms/Scalar/JumpThreading.h Mon Jun 13
>> 19:51:09 2016
>> @@ -0,0 +1,140 @@
>> +//===- JumpThreading.h - thread control through conditional BBs -*- C++
>> -*-===//
>> +//
>> +//                     The LLVM Compiler Infrastructure
>> +//
>> +// This file is distributed under the University of Illinois Open Source
>> +// License. See LICENSE.TXT for details.
>> +//
>>
>> +//===----------------------------------------------------------------------===//
>> +/// \file
>> +/// See the comments on JumpThreadingPass.
>> +///
>>
>> +//===----------------------------------------------------------------------===//
>> +
>> +#ifndef LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H
>> +#define LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H
>> +
>> +#include "llvm/ADT/DenseSet.h"
>> +#include "llvm/ADT/SmallPtrSet.h"
>> +#include "llvm/ADT/SmallSet.h"
>> +#include "llvm/Analysis/BlockFrequencyInfo.h"
>> +#include "llvm/Analysis/BranchProbabilityInfo.h"
>> +#include "llvm/Analysis/LazyValueInfo.h"
>> +#include "llvm/Analysis/TargetLibraryInfo.h"
>> +#include "llvm/IR/Instructions.h"
>> +#include "llvm/IR/ValueHandle.h"
>> +
>> +namespace llvm {
>> +
>> +/// A private "module" namespace for types and utilities used by
>> +/// JumpThreading.
>> +/// These are implementation details and should not be used by clients.
>> +namespace jumpthreading {
>> +// These are at global scope so static functions can use them too.
>> +typedef SmallVectorImpl<std::pair<Constant *, BasicBlock *>>
>> PredValueInfo;
>> +typedef SmallVector<std::pair<Constant *, BasicBlock *>, 8>
>> PredValueInfoTy;
>> +
>> +// This is used to keep track of what kind of constant we're currently
>> hoping
>> +// to find.
>> +enum ConstantPreference { WantInteger, WantBlockAddress };
>> +}
>> +
>> +/// This pass performs 'jump threading', which looks at blocks that have
>> +/// multiple predecessors and multiple successors.  If one or more of the
>> +/// predecessors of the block can be proven to always jump to one of the
>> +/// successors, we forward the edge from the predecessor to the
>> successor by
>> +/// duplicating the contents of this block.
>> +///
>> +/// An example of when this can occur is code like this:
>> +///
>> +///   if () { ...
>> +///     X = 4;
>> +///   }
>> +///   if (X < 3) {
>> +///
>> +/// In this case, the unconditional branch at the end of the first if
>> can be
>> +/// revectored to the false side of the second if.
>> +///
>> +class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
>> +  TargetLibraryInfo *TLI;
>> +  LazyValueInfo *LVI;
>> +  std::unique_ptr<BlockFrequencyInfo> BFI;
>> +  std::unique_ptr<BranchProbabilityInfo> BPI;
>> +  bool HasProfileData;
>> +#ifdef NDEBUG
>> +  SmallPtrSet<const BasicBlock *, 16> LoopHeaders;
>> +#else
>> +  SmallSet<AssertingVH<const BasicBlock>, 16> LoopHeaders;
>> +#endif
>> +  DenseSet<std::pair<Value *, BasicBlock *>> RecursionSet;
>> +
>> +  unsigned BBDupThreshold;
>> +
>> +  // RAII helper for updating the recursion stack.
>> +  struct RecursionSetRemover {
>> +    DenseSet<std::pair<Value *, BasicBlock *>> &TheSet;
>> +    std::pair<Value *, BasicBlock *> ThePair;
>> +
>> +    RecursionSetRemover(DenseSet<std::pair<Value *, BasicBlock *>> &S,
>> +                        std::pair<Value *, BasicBlock *> P)
>> +        : TheSet(S), ThePair(P) {}
>> +
>> +    ~RecursionSetRemover() { TheSet.erase(ThePair); }
>> +  };
>> +
>> +public:
>> +  JumpThreadingPass(int T = -1);
>> +  // Hack for MSVC 2013 which seems like it can't synthesize this.
>> +  JumpThreadingPass(JumpThreadingPass &&Other)
>> +      : TLI(Other.TLI), LVI(Other.LVI), BFI(std::move(Other.BFI)),
>> +        BPI(std::move(Other.BPI)), HasProfileData(Other.HasProfileData),
>> +        LoopHeaders(std::move(Other.LoopHeaders)),
>> +        RecursionSet(std::move(Other.RecursionSet)),
>> +        BBDupThreshold(Other.BBDupThreshold) {}
>> +
>> +  // Glue for old PM.
>> +  bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,
>> +               bool HasProfileData_, std::unique_ptr<BlockFrequencyInfo>
>> BFI_,
>> +               std::unique_ptr<BranchProbabilityInfo> BPI_);
>> +
>> +  PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
>> +
>> +  void releaseMemory() {
>> +    BFI.reset();
>> +    BPI.reset();
>> +  }
>> +
>> +  void FindLoopHeaders(Function &F);
>> +  bool ProcessBlock(BasicBlock *BB);
>> +  bool ThreadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *>
>> &PredBBs,
>> +                  BasicBlock *SuccBB);
>> +  bool DuplicateCondBranchOnPHIIntoPred(
>> +      BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs);
>> +
>> +  bool
>> +  ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,
>> +                                  jumpthreading::PredValueInfo &Result,
>> +                                  jumpthreading::ConstantPreference
>> Preference,
>> +                                  Instruction *CxtI = nullptr);
>> +  bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
>> +                              jumpthreading::ConstantPreference
>> Preference,
>> +                              Instruction *CxtI = nullptr);
>> +
>> +  bool ProcessBranchOnPHI(PHINode *PN);
>> +  bool ProcessBranchOnXOR(BinaryOperator *BO);
>> +  bool ProcessImpliedCondition(BasicBlock *BB);
>> +
>> +  bool SimplifyPartiallyRedundantLoad(LoadInst *LI);
>> +  bool TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
>> +  bool TryToUnfoldSelectInCurrBB(BasicBlock *BB);
>> +
>> +private:
>> +  BasicBlock *SplitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *>
>> Preds,
>> +                              const char *Suffix);
>> +  void UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
>> +                                    BasicBlock *NewBB, BasicBlock
>> *SuccBB);
>> +};
>> +
>> +} // end namespace llvm
>> +
>> +#endif
>>
>> Modified: llvm/trunk/lib/Passes/PassBuilder.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Passes/PassBuilder.cpp?rev=272607&r1=272606&r2=272607&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/Passes/PassBuilder.cpp (original)
>> +++ llvm/trunk/lib/Passes/PassBuilder.cpp Mon Jun 13 19:51:09 2016
>> @@ -75,6 +75,7 @@
>>  #include "llvm/Transforms/Scalar/GVN.h"
>>  #include "llvm/Transforms/Scalar/GuardWidening.h"
>>  #include "llvm/Transforms/Scalar/IndVarSimplify.h"
>> +#include "llvm/Transforms/Scalar/JumpThreading.h"
>>  #include "llvm/Transforms/Scalar/LoopRotation.h"
>>  #include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
>>  #include "llvm/Transforms/Scalar/LowerAtomic.h"
>>
>> Modified: llvm/trunk/lib/Passes/PassRegistry.def
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Passes/PassRegistry.def?rev=272607&r1=272606&r2=272607&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/Passes/PassRegistry.def (original)
>> +++ llvm/trunk/lib/Passes/PassRegistry.def Mon Jun 13 19:51:09 2016
>> @@ -130,6 +130,7 @@ FUNCTION_PASS("lower-expect", LowerExpec
>>  FUNCTION_PASS("guard-widening", GuardWideningPass())
>>  FUNCTION_PASS("gvn", GVN())
>>  FUNCTION_PASS("mldst-motion", MergedLoadStoreMotionPass())
>> +FUNCTION_PASS("jump-threading", JumpThreadingPass())
>>  FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass())
>>  FUNCTION_PASS("lcssa", LCSSAPass())
>>  FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
>>
>> Modified: llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp?rev=272607&r1=272606&r2=272607&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp (original)
>> +++ llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp Mon Jun 13
>> 19:51:09 2016
>> @@ -11,31 +11,25 @@
>>  //
>>
>>  //===----------------------------------------------------------------------===//
>>
>> +#include "llvm/Transforms/Scalar/JumpThreading.h"
>>  #include "llvm/Transforms/Scalar.h"
>>  #include "llvm/ADT/DenseMap.h"
>>  #include "llvm/ADT/DenseSet.h"
>>  #include "llvm/ADT/STLExtras.h"
>> -#include "llvm/ADT/SmallPtrSet.h"
>> -#include "llvm/ADT/SmallSet.h"
>>  #include "llvm/ADT/Statistic.h"
>>  #include "llvm/Analysis/GlobalsModRef.h"
>>  #include "llvm/Analysis/CFG.h"
>> -#include "llvm/Analysis/BlockFrequencyInfo.h"
>>  #include "llvm/Analysis/BlockFrequencyInfoImpl.h"
>> -#include "llvm/Analysis/BranchProbabilityInfo.h"
>>  #include "llvm/Analysis/ConstantFolding.h"
>>  #include "llvm/Analysis/InstructionSimplify.h"
>> -#include "llvm/Analysis/LazyValueInfo.h"
>>  #include "llvm/Analysis/Loads.h"
>>  #include "llvm/Analysis/LoopInfo.h"
>> -#include "llvm/Analysis/TargetLibraryInfo.h"
>>  #include "llvm/Analysis/ValueTracking.h"
>>  #include "llvm/IR/DataLayout.h"
>>  #include "llvm/IR/IntrinsicInst.h"
>>  #include "llvm/IR/LLVMContext.h"
>>  #include "llvm/IR/MDBuilder.h"
>>  #include "llvm/IR/Metadata.h"
>> -#include "llvm/IR/ValueHandle.h"
>>  #include "llvm/Pass.h"
>>  #include "llvm/Support/CommandLine.h"
>>  #include "llvm/Support/Debug.h"
>> @@ -46,6 +40,7 @@
>>  #include <algorithm>
>>  #include <memory>
>>  using namespace llvm;
>> +using namespace jumpthreading;
>>
>>  #define DEBUG_TYPE "jump-threading"
>>
>> @@ -66,17 +61,6 @@ ImplicationSearchThreshold(
>>    cl::init(3), cl::Hidden);
>>
>>  namespace {
>> -  // These are at global scope so static functions can use them too.
>> -  typedef SmallVectorImpl<std::pair<Constant*, BasicBlock*> >
>> PredValueInfo;
>> -  typedef SmallVector<std::pair<Constant*, BasicBlock*>, 8>
>> PredValueInfoTy;
>> -
>> -  // This is used to keep track of what kind of constant we're currently
>> hoping
>> -  // to find.
>> -  enum ConstantPreference {
>> -    WantInteger,
>> -    WantBlockAddress
>> -  };
>> -
>>    /// This pass performs 'jump threading', which looks at blocks that
>> have
>>    /// multiple predecessors and multiple successors.  If one or more of
>> the
>>    /// predecessors of the block can be proven to always jump to one of
>> the
>> @@ -94,37 +78,11 @@ namespace {
>>    /// revectored to the false side of the second if.
>>    ///
>>    class JumpThreading : public FunctionPass {
>> -    TargetLibraryInfo *TLI;
>> -    LazyValueInfo *LVI;
>> -    std::unique_ptr<BlockFrequencyInfo> BFI;
>> -    std::unique_ptr<BranchProbabilityInfo> BPI;
>> -    bool HasProfileData;
>> -#ifdef NDEBUG
>> -    SmallPtrSet<const BasicBlock *, 16> LoopHeaders;
>> -#else
>> -    SmallSet<AssertingVH<const BasicBlock>, 16> LoopHeaders;
>> -#endif
>> -    DenseSet<std::pair<Value*, BasicBlock*> > RecursionSet;
>> -
>> -    unsigned BBDupThreshold;
>> -
>> -    // RAII helper for updating the recursion stack.
>> -    struct RecursionSetRemover {
>> -      DenseSet<std::pair<Value*, BasicBlock*> > &TheSet;
>> -      std::pair<Value*, BasicBlock*> ThePair;
>> -
>> -      RecursionSetRemover(DenseSet<std::pair<Value*, BasicBlock*> > &S,
>> -                          std::pair<Value*, BasicBlock*> P)
>> -        : TheSet(S), ThePair(P) { }
>> +    JumpThreadingPass Impl;
>>
>> -      ~RecursionSetRemover() {
>> -        TheSet.erase(ThePair);
>> -      }
>> -    };
>>    public:
>>      static char ID; // Pass identification
>> -    JumpThreading(int T = -1) : FunctionPass(ID) {
>> -      BBDupThreshold = (T == -1) ? BBDuplicateThreshold : unsigned(T);
>> +    JumpThreading(int T = -1) : FunctionPass(ID), Impl(T) {
>>        initializeJumpThreadingPass(*PassRegistry::getPassRegistry());
>>      }
>>
>> @@ -137,39 +95,7 @@ namespace {
>>        AU.addRequired<TargetLibraryInfoWrapperPass>();
>>      }
>>
>> -    void releaseMemory() override {
>> -      BFI.reset();
>> -      BPI.reset();
>> -    }
>> -
>> -    void FindLoopHeaders(Function &F);
>> -    bool ProcessBlock(BasicBlock *BB);
>> -    bool ThreadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock*>
>> &PredBBs,
>> -                    BasicBlock *SuccBB);
>> -    bool DuplicateCondBranchOnPHIIntoPred(BasicBlock *BB,
>> -                                  const SmallVectorImpl<BasicBlock *>
>> &PredBBs);
>> -
>> -    bool ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,
>> -                                         PredValueInfo &Result,
>> -                                         ConstantPreference Preference,
>> -                                         Instruction *CxtI = nullptr);
>> -    bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
>> -                                ConstantPreference Preference,
>> -                                Instruction *CxtI = nullptr);
>> -
>> -    bool ProcessBranchOnPHI(PHINode *PN);
>> -    bool ProcessBranchOnXOR(BinaryOperator *BO);
>> -    bool ProcessImpliedCondition(BasicBlock *BB);
>> -
>> -    bool SimplifyPartiallyRedundantLoad(LoadInst *LI);
>> -    bool TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
>> -    bool TryToUnfoldSelectInCurrBB(BasicBlock *BB);
>> -
>> -  private:
>> -    BasicBlock *SplitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *>
>> Preds,
>> -                                const char *Suffix);
>> -    void UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
>> -                                      BasicBlock *NewBB, BasicBlock
>> *SuccBB);
>> +    void releaseMemory() override { Impl.releaseMemory(); }
>>    };
>>  }
>>
>> @@ -184,24 +110,68 @@ INITIALIZE_PASS_END(JumpThreading, "jump
>>  // Public interface to the Jump Threading pass
>>  FunctionPass *llvm::createJumpThreadingPass(int Threshold) { return new
>> JumpThreading(Threshold); }
>>
>> +JumpThreadingPass::JumpThreadingPass(int T) {
>> +  BBDupThreshold = (T == -1) ? BBDuplicateThreshold : unsigned(T);
>> +}
>> +
>>  /// runOnFunction - Top level algorithm.
>>  ///
>>  bool JumpThreading::runOnFunction(Function &F) {
>>    if (skipFunction(F))
>>      return false;
>> +  auto TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
>> +  auto LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
>> +  std::unique_ptr<BlockFrequencyInfo> BFI;
>> +  std::unique_ptr<BranchProbabilityInfo> BPI;
>> +  bool HasProfileData = F.getEntryCount().hasValue();
>> +  if (HasProfileData) {
>> +    LoopInfo LI{DominatorTree(F)};
>> +    BPI.reset(new BranchProbabilityInfo(F, LI));
>> +    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
>> +  }
>> +  return Impl.runImpl(F, TLI, LVI, HasProfileData, std::move(BFI),
>> +                      std::move(BPI));
>> +}
>> +
>> +PreservedAnalyses JumpThreadingPass::run(Function &F,
>> +                                         AnalysisManager<Function> &AM) {
>> +
>> +  auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
>> +  auto &LVI = AM.getResult<LazyValueAnalysis>(F);
>> +  std::unique_ptr<BlockFrequencyInfo> BFI;
>> +  std::unique_ptr<BranchProbabilityInfo> BPI;
>> +  bool HasProfileData = F.getEntryCount().hasValue();
>> +  if (HasProfileData) {
>> +    LoopInfo LI{DominatorTree(F)};
>> +    BPI.reset(new BranchProbabilityInfo(F, LI));
>> +    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
>> +  }
>> +  bool Changed =
>> +      runImpl(F, &TLI, &LVI, HasProfileData, std::move(BFI),
>> std::move(BPI));
>> +  if (!Changed)
>> +    return PreservedAnalyses::all();
>> +  PreservedAnalyses PA;
>> +  PA.preserve<LazyValueAnalysis>();
>> +  PA.preserve<GlobalsAA>();
>> +  return PreservedAnalyses::none();
>> +}
>> +
>> +bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_,
>> +                                LazyValueInfo *LVI_, bool
>> HasProfileData_,
>> +                                std::unique_ptr<BlockFrequencyInfo> BFI_,
>> +                                std::unique_ptr<BranchProbabilityInfo>
>> BPI_) {
>>
>>    DEBUG(dbgs() << "Jump threading on function '" << F.getName() <<
>> "'\n");
>> -  TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
>> -  LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
>> +  TLI = TLI_;
>> +  LVI = LVI_;
>>    BFI.reset();
>>    BPI.reset();
>>    // When profile data is available, we need to update edge weights after
>>    // successful jump threading, which requires both BPI and BFI being
>> available.
>> -  HasProfileData = F.getEntryCount().hasValue();
>> +  HasProfileData = HasProfileData_;
>>    if (HasProfileData) {
>> -    LoopInfo LI{DominatorTree(F)};
>> -    BPI.reset(new BranchProbabilityInfo(F, LI));
>> -    BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
>> +    BPI = std::move(BPI_);
>> +    BFI = std::move(BFI_);
>>    }
>>
>>    // Remove unreachable blocks from function as they may result in
>> infinite
>> @@ -364,7 +334,7 @@ static unsigned getJumpThreadDuplication
>>  /// enough to track all of these properties and keep it up-to-date as
>> the CFG
>>  /// mutates, so we don't allow any of these transformations.
>>  ///
>> -void JumpThreading::FindLoopHeaders(Function &F) {
>> +void JumpThreadingPass::FindLoopHeaders(Function &F) {
>>    SmallVector<std::pair<const BasicBlock*,const BasicBlock*>, 32> Edges;
>>    FindFunctionBackedges(F, Edges);
>>
>> @@ -398,10 +368,9 @@ static Constant *getKnownConstant(Value
>>  ///
>>  /// This returns true if there were any known values.
>>  ///
>> -bool JumpThreading::
>> -ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo
>> &Result,
>> -                                ConstantPreference Preference,
>> -                                Instruction *CxtI) {
>> +bool JumpThreadingPass::ComputeValueKnownInPredecessors(
>> +    Value *V, BasicBlock *BB, PredValueInfo &Result,
>> +    ConstantPreference Preference, Instruction *CxtI) {
>>    // This method walks up use-def chains recursively.  Because of this,
>> we could
>>    // get into an infinite loop going around loops in the use-def chain.
>> To
>>    // prevent this, keep track of what (value, block) pairs we've already
>> visited
>> @@ -727,7 +696,7 @@ static bool hasAddressTakenAndUsed(Basic
>>
>>  /// ProcessBlock - If there are any predecessors whose control can be
>> threaded
>>  /// through to a successor, transform them now.
>> -bool JumpThreading::ProcessBlock(BasicBlock *BB) {
>> +bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
>>    // If the block is trivially dead, just return and let the caller nuke
>> it.
>>    // This simplifies other transformations.
>>    if (pred_empty(BB) &&
>> @@ -911,7 +880,7 @@ bool JumpThreading::ProcessBlock(BasicBl
>>    return false;
>>  }
>>
>> -bool JumpThreading::ProcessImpliedCondition(BasicBlock *BB) {
>> +bool JumpThreadingPass::ProcessImpliedCondition(BasicBlock *BB) {
>>    auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
>>    if (!BI || !BI->isConditional())
>>      return false;
>> @@ -950,7 +919,7 @@ bool JumpThreading::ProcessImpliedCondit
>>  /// load instruction, eliminate it by replacing it with a PHI node.
>> This is an
>>  /// important optimization that encourages jump threading, and needs to
>> be run
>>  /// interlaced with other jump threading tasks.
>> -bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
>> +bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
>>    // Don't hack volatile/atomic loads.
>>    if (!LI->isSimple()) return false;
>>
>> @@ -1198,9 +1167,9 @@ FindMostPopularDest(BasicBlock *BB,
>>    return MostPopularDest;
>>  }
>>
>> -bool JumpThreading::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
>> -                                           ConstantPreference Preference,
>> -                                           Instruction *CxtI) {
>> +bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock
>> *BB,
>> +                                               ConstantPreference
>> Preference,
>> +                                               Instruction *CxtI) {
>>    // If threading this would thread across a loop header, don't even try
>> to
>>    // thread the edge.
>>    if (LoopHeaders.count(BB))
>> @@ -1306,7 +1275,7 @@ bool JumpThreading::ProcessThreadableEdg
>>  /// a PHI node in the current block.  See if there are any
>> simplifications we
>>  /// can do based on inputs to the phi node.
>>  ///
>> -bool JumpThreading::ProcessBranchOnPHI(PHINode *PN) {
>> +bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) {
>>    BasicBlock *BB = PN->getParent();
>>
>>    // TODO: We could make use of this to do it once for blocks with
>> common PHI
>> @@ -1336,7 +1305,7 @@ bool JumpThreading::ProcessBranchOnPHI(P
>>  /// a xor instruction in the current block.  See if there are any
>>  /// simplifications we can do based on inputs to the xor.
>>  ///
>> -bool JumpThreading::ProcessBranchOnXOR(BinaryOperator *BO) {
>> +bool JumpThreadingPass::ProcessBranchOnXOR(BinaryOperator *BO) {
>>    BasicBlock *BB = BO->getParent();
>>
>>    // If either the LHS or RHS of the xor is a constant, don't do this
>> @@ -1464,9 +1433,9 @@ static void AddPHINodeEntriesForMappedBl
>>  /// ThreadEdge - We have decided that it is safe and profitable to
>> factor the
>>  /// blocks in PredBBs to one predecessor, then thread an edge from it to
>> SuccBB
>>  /// across BB.  Transform the IR to reflect this change.
>> -bool JumpThreading::ThreadEdge(BasicBlock *BB,
>> -                               const SmallVectorImpl<BasicBlock*>
>> &PredBBs,
>> -                               BasicBlock *SuccBB) {
>> +bool JumpThreadingPass::ThreadEdge(BasicBlock *BB,
>> +                                   const SmallVectorImpl<BasicBlock *>
>> &PredBBs,
>> +                                   BasicBlock *SuccBB) {
>>    // If threading to the same block as we come from, we would infinite
>> loop.
>>    if (SuccBB == BB) {
>>      DEBUG(dbgs() << "  Not threading across BB '" << BB->getName()
>> @@ -1620,9 +1589,9 @@ bool JumpThreading::ThreadEdge(BasicBloc
>>  /// Create a new basic block that will be the predecessor of BB and
>> successor of
>>  /// all blocks in Preds. When profile data is availble, update the
>> frequency of
>>  /// this new block.
>> -BasicBlock *JumpThreading::SplitBlockPreds(BasicBlock *BB,
>> -                                           ArrayRef<BasicBlock *> Preds,
>> -                                           const char *Suffix) {
>> +BasicBlock *JumpThreadingPass::SplitBlockPreds(BasicBlock *BB,
>> +                                               ArrayRef<BasicBlock *>
>> Preds,
>> +                                               const char *Suffix) {
>>    // Collect the frequencies of all predecessors of BB, which will be
>> used to
>>    // update the edge weight on BB->SuccBB.
>>    BlockFrequency PredBBFreq(0);
>> @@ -1642,10 +1611,10 @@ BasicBlock *JumpThreading::SplitBlockPre
>>  /// Update the block frequency of BB and branch weight and the metadata
>> on the
>>  /// edge BB->SuccBB. This is done by scaling the weight of BB->SuccBB by
>> 1 -
>>  /// Freq(PredBB->BB) / Freq(BB->SuccBB).
>> -void JumpThreading::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB,
>> -                                                 BasicBlock *BB,
>> -                                                 BasicBlock *NewBB,
>> -                                                 BasicBlock *SuccBB) {
>> +void JumpThreadingPass::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB,
>> +                                                     BasicBlock *BB,
>> +                                                     BasicBlock *NewBB,
>> +                                                     BasicBlock *SuccBB)
>> {
>>    if (!HasProfileData)
>>      return;
>>
>> @@ -1706,8 +1675,8 @@ void JumpThreading::UpdateBlockFreqAndEd
>>  /// If we can duplicate the contents of BB up into PredBB do so now, this
>>  /// improves the odds that the branch will be on an analyzable
>> instruction like
>>  /// a compare.
>> -bool JumpThreading::DuplicateCondBranchOnPHIIntoPred(BasicBlock *BB,
>> -                                 const SmallVectorImpl<BasicBlock *>
>> &PredBBs) {
>> +bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred(
>> +    BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs) {
>>    assert(!PredBBs.empty() && "Can't handle an empty set");
>>
>>    // If BB is a loop header, then duplicating this block outside the
>> loop would
>> @@ -1856,7 +1825,7 @@ bool JumpThreading::DuplicateCondBranchO
>>  ///
>>  /// And expand the select into a branch structure if one of its arms
>> allows %c
>>  /// to be folded. This later enables threading from bb1 over bb2.
>> -bool JumpThreading::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) {
>> +bool JumpThreadingPass::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock
>> *BB) {
>>    BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
>>    PHINode *CondLHS = dyn_cast<PHINode>(CondCmp->getOperand(0));
>>    Constant *CondRHS = cast<Constant>(CondCmp->getOperand(1));
>> @@ -1934,7 +1903,7 @@ bool JumpThreading::TryToUnfoldSelect(Cm
>>  /// select if the associated PHI has at least one constant.  If the
>> unfolded
>>  /// select is not jump-threaded, it will be folded again in the later
>>  /// optimizations.
>> -bool JumpThreading::TryToUnfoldSelectInCurrBB(BasicBlock *BB) {
>> +bool JumpThreadingPass::TryToUnfoldSelectInCurrBB(BasicBlock *BB) {
>>    // If threading this would thread across a loop header, don't thread
>> the edge.
>>    // See the comments above FindLoopHeaders for justifications and
>> caveats.
>>    if (LoopHeaders.count(BB))
>>
>> Modified: llvm/trunk/test/Transforms/JumpThreading/thread-loads.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/JumpThreading/thread-loads.ll?rev=272607&r1=272606&r2=272607&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/Transforms/JumpThreading/thread-loads.ll (original)
>> +++ llvm/trunk/test/Transforms/JumpThreading/thread-loads.ll Mon Jun 13
>> 19:51:09 2016
>> @@ -1,4 +1,5 @@
>>  ; RUN: opt < %s -jump-threading -S | FileCheck %s
>> +; RUN: opt < %s -passes=jump-threading -S | FileCheck %s
>>
>>  target datalayout =
>> "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
>>  target triple = "i386-apple-darwin7"
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160613/44fdc2ca/attachment-0001.html>


More information about the llvm-commits mailing list