SROA: move AATags member into base OpSplitter class. NFC.

[t.p.northover]

Summary

Split out from https://reviews.llvm.org/D54743.

The member was duplicated in all users of the class so it makes sense to live there. Additionally, incoming alignment handling makes even more sense in the base class and makes added consistency an argument.

[chandlerc]

LGTM

llvm/lib/Transforms/Scalar/SROA.cpp

protected:
     /// The indices to a GEP instruction which will move Ptr to the correct slot
     /// within the aggregate.
     SmallVector<Value *, 4> GEPIndices;
 
     /// The base pointer of the original op, used as a base for GEPing the
     /// split operations.
     Value *Ptr;
 
+    /// TBAA information to attach to the new op.
+    AAMDNodes AATags;
+
     /// Initialize the splitter with an insertion point, Ptr and start with a
     /// single zero GEP index.
-    OpSplitter(Instruction *InsertionPoint, Value *Ptr)
-        : IRB(InsertionPoint), GEPIndices(1, IRB.getInt32(0)), Ptr(Ptr) {}
+    OpSplitter(Instruction *InsertionPoint, Value *Ptr, AAMDNodes AATags)
+        : IRB(InsertionPoint), GEPIndices(1, IRB.getInt32(0)), Ptr(Ptr),
+          AATags(AATags) {}
 
   public:
     /// Generic recursive split emission routine.
     ///
     /// This method recursively splits an aggregate op (load or store) into
     /// scalar or vector ops. It splits recursively until it hits a single value
     /// and emits that single value operation via the template argument.
     ///
void emitSplitOps(Type *Ty, Value *&Agg, const Twine &Name) {
         return;
       }
 
       llvm_unreachable("Only arrays and structs are aggregate loadable types");
     }
   };
 
   struct LoadOpSplitter : public OpSplitter<LoadOpSplitter> {
-    AAMDNodes AATags;
-
     LoadOpSplitter(Instruction *InsertionPoint, Value *Ptr, AAMDNodes AATags)
-        : OpSplitter<LoadOpSplitter>(InsertionPoint, Ptr), AATags(AATags) {}
+        : OpSplitter<LoadOpSplitter>(InsertionPoint, Ptr, AATags) {}
 
     /// Emit a leaf load of a single value. This is called at the leaves of the
     /// recursive emission to actually load values.
     void emitFunc(Type *Ty, Value *&Agg, const Twine &Name) {
       assert(Ty->isSingleValueType());
       // Load the single value and insert it using the indices.
       Value *GEP =
           IRB.CreateInBoundsGEP(nullptr, Ptr, GEPIndices, Name + ".gep");
bool visitLoadInst(LoadInst &LI) {
     Splitter.emitSplitOps(LI.getType(), V, LI.getName() + ".fca");
     LI.replaceAllUsesWith(V);
     LI.eraseFromParent();
     return true;
   }
 
   struct StoreOpSplitter : public OpSplitter<StoreOpSplitter> {
     StoreOpSplitter(Instruction *InsertionPoint, Value *Ptr, AAMDNodes AATags)
-        : OpSplitter<StoreOpSplitter>(InsertionPoint, Ptr), AATags(AATags) {}
-    AAMDNodes AATags;
+        : OpSplitter<StoreOpSplitter>(InsertionPoint, Ptr, AATags) {}
 
     /// Emit a leaf store of a single value. This is called at the leaves of the
     /// recursive emission to actually produce stores.
     void emitFunc(Type *Ty, Value *&Agg, const Twine &Name) {
       assert(Ty->isSingleValueType());
       // Extract the single value and store it using the indices.
       //
       // The gep and extractvalue values are factored out of the CreateStore