Add new constructors for LoopInfo/DominatorTree/BFI/BPI

[congh]

Summary

Those new constructors make it more natural to construct an object for a function. For example, previously to build a LoopInfo for a function, we need four statements:

DominatorTree DT;
LoopInfo LI;
DT.recalculate(F);
LI.analyze(DT);

Now we only need one statement:

LoopInfo LI(DominatorTree(F));

[hfinkel]

LGTM.

[congh]

This patch is already merged into the trunk.

include/llvm/Analysis/BlockFrequencyInfo.h

 
 /// BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to
 /// estimate IR basic block frequencies.
 class BlockFrequencyInfo {
   typedef BlockFrequencyInfoImpl<BasicBlock> ImplType;
   std::unique_ptr<ImplType> BFI;
 
 public:
+  BlockFrequencyInfo();
+  BlockFrequencyInfo(const Function &F, const BranchProbabilityInfo &BPI,
+                     const LoopInfo &LI);
+
   const Function *getFunction() const;
   void view() const;
 
   /// getblockFreq - Return block frequency. Return 0 if we don't have the
   /// information. Please note that initial frequency is equal to ENTRY_FREQ. It
   /// means that we should not rely on the value itself, but only on the
   /// comparison to the other block frequencies. We do this to avoid using of
   /// floating points.

include/llvm/Analysis/BranchProbabilityInfo.h

 /// probabilities of other edges from the block. The probabilites of all edges
 /// from a block sum to exactly one (100%).
 /// We use a pair (PredBlock and an index in the successors) to uniquely
 /// identify an edge, since we can have multiple edges from Src to Dst.
 /// As an example, we can have a switch which jumps to Dst with value 0 and
 /// value 10.
 class BranchProbabilityInfo {
 public:
+  BranchProbabilityInfo() {}
+  BranchProbabilityInfo(Function &F, const LoopInfo &LI) { calculate(F, LI); }
+
   void releaseMemory();
 
   void print(raw_ostream &OS) const;
 
   /// \brief Get an edge's probability, relative to other out-edges of the Src.
   ///
   /// This routine provides access to the fractional probability between zero
   /// (0%) and one (100%) of this edge executing, relative to other edges

include/llvm/Analysis/LoopInfo.h

class LoopInfo : public LoopInfoBase<BasicBlock, Loop> {
   typedef LoopInfoBase<BasicBlock, Loop> BaseT;
 
   friend class LoopBase<BasicBlock, Loop>;
 
   void operator=(const LoopInfo &) = delete;
   LoopInfo(const LoopInfo &) = delete;
 public:
   LoopInfo() {}
+  explicit LoopInfo(const DominatorTreeBase<BasicBlock> &DomTree);
 
   LoopInfo(LoopInfo &&Arg) : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
   LoopInfo &operator=(LoopInfo &&RHS) {
     BaseT::operator=(std::move(static_cast<BaseT &>(RHS)));
     return *this;
   }
 
   // Most of the public interface is provided via LoopInfoBase.

include/llvm/IR/Dominators.h

 
 /// \brief Concrete subclass of DominatorTreeBase that is used to compute a
 /// normal dominator tree.
 class DominatorTree : public DominatorTreeBase<BasicBlock> {
 public:
   typedef DominatorTreeBase<BasicBlock> Base;
 
   DominatorTree() : DominatorTreeBase<BasicBlock>(false) {}
+  explicit DominatorTree(Function &F) : DominatorTreeBase<BasicBlock>(false) {
+    recalculate(F);
+  }
 
   DominatorTree(DominatorTree &&Arg)
       : Base(std::move(static_cast<Base &>(Arg))) {}
   DominatorTree &operator=(DominatorTree &&RHS) {
     Base::operator=(std::move(static_cast<Base &>(RHS)));
     return *this;
   }
 

lib/Analysis/BlockFrequencyInfo.cpp

std::string getNodeLabel(const BasicBlock *Node,
 
     return Result;
   }
 };
 
 } // end namespace llvm
 #endif
 
+BlockFrequencyInfo::BlockFrequencyInfo() {}
+
+BlockFrequencyInfo::BlockFrequencyInfo(const Function &F,
+                                       const BranchProbabilityInfo &BPI,
+                                       const LoopInfo &LI) {
+  calculate(F, BPI, LI);
+}
+
 void BlockFrequencyInfo::calculate(const Function &F,
                                    const BranchProbabilityInfo &BPI,
                                    const LoopInfo &LI) {
   if (!BFI)
     BFI.reset(new ImplType);
   BFI->calculate(F, BPI, LI);
 #ifndef NDEBUG
   if (ViewBlockFreqPropagationDAG != GVDT_None)

lib/Analysis/LoopInfo.cpp

Loop *UnloopUpdater::getNearestLoop(BasicBlock *BB, Loop *BBLoop) {
   }
   if (Subloop) {
     SubloopParents[Subloop] = NearLoop;
     return BBLoop;
   }
   return NearLoop;
 }
 
+LoopInfo::LoopInfo(const DominatorTreeBase<BasicBlock> &DomTree) {
+  analyze(DomTree);
+}
+
 /// updateUnloop - The last backedge has been removed from a loop--now the
 /// "unloop". Find a new parent for the blocks contained within unloop and
 /// update the loop tree. We don't necessarily have valid dominators at this
 /// point, but LoopInfo is still valid except for the removal of this loop.
 ///
 /// Note that Unloop may now be an empty loop. Calling Loop::getHeader without
 /// checking first is illegal.
 void LoopInfo::updateUnloop(Loop *Unloop) {