[LSV] Nix two global (ish) variables in the LoadStoreVectorizer. NFC

[asbirlea]

LGTM.

llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

 STATISTIC(NumVectorInstructions, "Number of vector accesses generated");
 STATISTIC(NumScalarsVectorized, "Number of scalar accesses vectorized");
 
 namespace {
 
 // TODO: Remove this
 static const unsigned TargetBaseAlign = 4;
 
-class Vectorizer {
-  typedef SmallVector<Value *, 8> ValueList;
-  typedef MapVector<Value *, ValueList> ValueListMap;
 
+class Vectorizer {
   Function &F;
   AliasAnalysis &AA;
   DominatorTree &DT;
   ScalarEvolution &SE;
   TargetTransformInfo &TTI;
   const DataLayout &DL;
   IRBuilder<> Builder;
-  ValueListMap StoreRefs;
-  ValueListMap LoadRefs;
 
 public:
   Vectorizer(Function &F, AliasAnalysis &AA, DominatorTree &DT,
              ScalarEvolution &SE, TargetTransformInfo &TTI)
       : F(F), AA(AA), DT(DT), SE(SE), TTI(TTI),
         DL(F.getParent()->getDataLayout()), Builder(SE.getContext()) {}
 
   bool run();
private:
   /// in the chain between \p From and \p To. Returns Index, where
   /// \p Chain[0, Index) is the largest vectorizable chain prefix.
   /// The elements of \p Chain should be all loads or all stores.
   unsigned getVectorizablePrefixEndIdx(ArrayRef<Value *> Chain,
                                        BasicBlock::iterator From,
                                        BasicBlock::iterator To);
 
   /// Collects load and store instructions to vectorize.
-  void collectInstructions(BasicBlock *BB);
+  std::pair<ValueListMap, ValueListMap> collectInstructions(BasicBlock *BB);
 
   /// Processes the collected instructions, the \p Map. The elements of \p Map
   /// should be all loads or all stores.
   bool vectorizeChains(ValueListMap &Map);
 
   /// Finds the load/stores to consecutive memory addresses and vectorizes them.
   bool vectorizeInstructions(ArrayRef<Value *> Instrs);
 

 }
 
 // Vectorizer Implementation
 bool Vectorizer::run() {
   bool Changed = false;
 
   // Scan the blocks in the function in post order.
   for (BasicBlock *BB : post_order(&F)) {
-    collectInstructions(BB);
+    ValueListMap LoadRefs, StoreRefs;
+    std::tie(LoadRefs, StoreRefs) = collectInstructions(BB);
     Changed |= vectorizeChains(LoadRefs);
     Changed |= vectorizeChains(StoreRefs);
   }
 
   return Changed;
 }
 
 Value *Vectorizer::getPointerOperand(Value *I) {
for (auto EntryMem : MemoryInstrs) {
         return ChainIdx;
       }
     }
     ChainIdx++;
   }
   return Chain.size();
 }
 
-void Vectorizer::collectInstructions(BasicBlock *BB) {
-  LoadRefs.clear();
-  StoreRefs.clear();
+std::pair<ValueListMap, ValueListMap>
+Vectorizer::collectInstructions(BasicBlock *BB) {
+  ValueListMap LoadRefs;
+  ValueListMap StoreRefs;
 
   for (Instruction &I : *BB) {
     if (!I.mayReadOrWriteMemory())
       continue;
 
     if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
       if (!LI->isSimple())
         continue;
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
           }))
         continue;
 
       // Save store location.
       Value *ObjPtr = GetUnderlyingObject(Ptr, DL);
       StoreRefs[ObjPtr].push_back(SI);
     }
   }
+
+  return {LoadRefs, StoreRefs};
 }
 
 bool Vectorizer::vectorizeChains(ValueListMap &Map) {
   bool Changed = false;
 
   for (const std::pair<Value *, ValueList> &Chain : Map) {
     unsigned Size = Chain.second.size();
     if (Size < 2)