[LoopVectorize] Factor out a global emitLoopAnalysis

[anemet]

Summary

The logic in emitAnalysis is duplicated across multiple functions. This
splits it into a global function. Another use will be added by the patchset.

NFC. This is part of the patchset that splits out the memory dependence logic
from LoopVectorizationLegality into a new class LoopAccessAnalysis.
LoopAccessAnalysis will be used by the new Loop Distribution pass.

[hfinkel]

LGTM.

[anemet]

Addresses Hal's comment from D7285: change this to Report::emitAnalysis rather
than a global function so that it's more hidden when this all becomes public.

[anemet]

r227748

lib/Transforms/Vectorize/LoopVectorize.cpp

template <typename A> Report &operator<<(const A &Value) {
     Out << Value;
     return *this;
   }
 
   Instruction *getInstr() { return Instr; }
 
   std::string &str() { return Out.str(); }
   operator Twine() { return Out.str(); }
+
+  /// \brief Emit an analysis note with the debug location from the instruction
+  /// in \p Message if available.  Otherwise use the location of \p TheLoop.
+  static void emitAnalysis(Report &Message, const Function *TheFunction,
+                           const Loop *TheLoop);
 };
 
 /// InnerLoopVectorizer vectorizes loops which contain only one basic
 /// block to a specified vectorization factor (VF).
 /// This class performs the widening of scalars into vectors, or multiple
 /// scalars. This class also implements the following features:
 /// * It inserts an epilogue loop for handling loops that don't have iteration
 ///   counts that are known to be a multiple of the vectorization factor.
if (Kind != LLVMContext::MD_tbaa &&
         Kind != LLVMContext::MD_noalias &&
         Kind != LLVMContext::MD_fpmath)
       continue;
 
     To->setMetadata(Kind, M.second);
   }
 }
 
+void Report::emitAnalysis(Report &Message, const Function *TheFunction,
+                          const Loop *TheLoop) {
+  DebugLoc DL = TheLoop->getStartLoc();
+  if (Instruction *I = Message.getInstr())
+    DL = I->getDebugLoc();
+  emitOptimizationRemarkAnalysis(TheFunction->getContext(), DEBUG_TYPE,
+                                 *TheFunction, DL, Message.str());
+}
+
 /// \brief Propagate known metadata from one instruction to a vector of others.
 static void propagateMetadata(SmallVectorImpl<Value *> &To, const Instruction *From) {
   for (Value *V : To)
     if (Instruction *I = dyn_cast<Instruction>(V))
       propagateMetadata(I, From);
 }
 
 namespace {
private:
   ///
   /// Looks for accesses like "a[i * StrideA]" where "StrideA" is loop
   /// invariant.
   void collectStridedAccess(Value *LoadOrStoreInst);
 
   /// Report an analysis message to assist the user in diagnosing loops that are
   /// not vectorized.
   void emitAnalysis(Report &Message) {
-    DebugLoc DL = TheLoop->getStartLoc();
-    if (Instruction *I = Message.getInstr())
-      DL = I->getDebugLoc();
-    emitOptimizationRemarkAnalysis(TheFunction->getContext(), DEBUG_TYPE,
-                                   *TheFunction, DL, Message.str());
+    Report::emitAnalysis(Message, TheFunction, TheLoop);
   }
 
   /// The loop that we evaluate.
   Loop *TheLoop;
   /// Scev analysis.
   ScalarEvolution *SE;
   /// DataLayout analysis.
   const DataLayout *DL;
private:
 
   /// Returns whether the instruction is a load or store and will be a emitted
   /// as a vector operation.
   bool isConsecutiveLoadOrStore(Instruction *I);
 
   /// Report an analysis message to assist the user in diagnosing loops that are
   /// not vectorized.
   void emitAnalysis(Report &Message) {
-    DebugLoc DL = TheLoop->getStartLoc();
-    if (Instruction *I = Message.getInstr())
-      DL = I->getDebugLoc();
-    emitOptimizationRemarkAnalysis(TheFunction->getContext(), DEBUG_TYPE,
-                                   *TheFunction, DL, Message.str());
+    Report::emitAnalysis(Message, TheFunction, TheLoop);
   }
 
   /// Values used only by @llvm.assume calls.
   SmallPtrSet<const Value *, 32> EphValues;
 
   /// The loop that we evaluate.
   Loop *TheLoop;
   /// Scev analysis.