[Polly][Refactor] Use only one BlockGenerator for a SCoP

[jdoerfert]

Summary

This change has two main purposes:
  1) We do not use a static interface to hide an object we create and
     destroy for every basic block we copy.
  2) We allow the BlockGenerator to store information between calls to
     the copyBB method. This will ease scalar/phi code generation
     later on.

While a lot of method signatures were changed this should not cause
any real behaviour change.

[jdoerfert]

Some notes.

include/polly/CodeGen/BlockGenerators.h

69

I forgot to copy the @param declarionts here.

91

This is part of the next patch and will be removed.

[grosser]

Hi,

this looks generally good to me.

Tobias

include/polly/CodeGen/BlockGenerators.h

120

The documentation is not consistent in this class, but it may still be good to document the newly added parameter here (same below).

[jdoerfert]

commited in r228443.

include/polly/CodeGen/BlockGenerators.h

 /// @brief Return true iff @p V is an intrinsic that we ignore during code
 ///        generation.
 bool isIgnoredIntrinsic(const llvm::Value *V);
 
 /// @brief Generate a new basic block for a polyhedral statement.
 ///
 /// The only public function exposed is generate().
 class BlockGenerator {
 public:
-  /// @brief Generate a new BasicBlock for a ScopStmt.
+  BlockGenerator(PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
+                 ScalarEvolution &SE, IslExprBuilder *ExprBuilder = nullptr);
+
+  /// @brief Copy the basic block.
+  ///
+  /// This copies the entire basic block and updates references to old values
+  /// with references to new values, as defined by GlobalMap.
   ///
-  /// @param Builder   The LLVM-IR Builder used to generate the statement. The
-  ///                  code is generated at the location, the Builder points to.
   /// @param Stmt      The statement to code generate.
-  /// @param GlobalMap A map that defines for certain Values referenced from the
-  ///                  original code new Values they should be replaced with.
-  /// @param P         A reference to the pass this function is called from.
-  ///                  The pass is needed to update other analysis.
-  /// @param LI        The loop info for the current function
-  /// @param SE        The scalar evolution info for the current function
-  /// @param Build       The AST build with the new schedule.
-  /// @param ExprBuilder An expression builder to generate new access functions.
-  static void generate(PollyIRBuilder &Builder, ScopStmt &Stmt,
-                       ValueMapT &GlobalMap, LoopToScevMapT &LTS, Pass *P,
-                       LoopInfo &LI, ScalarEvolution &SE,
-                       __isl_keep isl_ast_build *Build = nullptr,
-                       IslExprBuilder *ExprBuilder = nullptr) {
-    BlockGenerator Generator(Builder, Stmt, P, LI, SE, Build, ExprBuilder);
-    Generator.copyBB(GlobalMap, LTS);
-  }
+  /// @param GlobalMap A mapping from old values to their new values
+  ///                  (for values recalculated in the new ScoP, but not
+  ///                  within this basic block).
+  /// @param LTS       A map from old loops to new induction variables as SCEVs.
+  void copyBB(ScopStmt &Stmt, ValueMapT &GlobalMap, LoopToScevMapT &LTS);
 
 protected:
   PollyIRBuilder &Builder;
-  ScopStmt &Statement;
   Pass *P;
   LoopInfo &LI;
   ScalarEvolution &SE;
-  isl_ast_build *Build;
   IslExprBuilder *ExprBuilder;
-
-  BlockGenerator(PollyIRBuilder &B, ScopStmt &Stmt, Pass *P, LoopInfo &LI,
-                 ScalarEvolution &SE, __isl_keep isl_ast_build *Build,
-                 IslExprBuilder *ExprBuilder);
+  BasicBlock &EntryBB;
 
   /// @brief Get the new version of a value.
   ///
   /// Given an old value, we first check if a new version of this value is
   /// available in the BBMap or GlobalMap. In case it is not and the value can
   /// be recomputed using SCEV, we do so. If we can not recompute a value
   /// using SCEV, but we understand that the value is constant within the scop,
   /// we return the old value.  If the value can still not be derived, this
protected:
   ///                   within this basic block).
   /// @param L         The loop that surrounded the instruction that referenced
   ///                  this value in the original code. This loop is used to
   ///                  evaluate the scalar evolution at the right scope.
   ///
   /// @returns  o The old value, if it is still valid.
   ///           o The new value, if available.
   ///           o NULL, if no value is found.
-  Value *getNewValue(const Value *Old, ValueMapT &BBMap, ValueMapT &GlobalMap,
-                     LoopToScevMapT &LTS, Loop *L) const;
+  Value *getNewValue(ScopStmt &Stmt, const Value *Old, ValueMapT &BBMap,
+                     ValueMapT &GlobalMap, LoopToScevMapT &LTS, Loop *L) const;
 
-  void copyInstScalar(const Instruction *Inst, ValueMapT &BBMap,
+  void copyInstScalar(ScopStmt &Stmt, const Instruction *Inst, ValueMapT &BBMap,
                       ValueMapT &GlobalMap, LoopToScevMapT &LTS);
 
   /// @brief Get the innermost loop that surrounds an instruction.
   ///
   /// @param Inst The instruction for which we get the loop.
   /// @return The innermost loop that surrounds the instruction.
   Loop *getLoopForInst(const Instruction *Inst);
 
   /// @brief Get the new operand address according to access relation of @p MA.
-  Value *getNewAccessOperand(const MemoryAccess &MA);
+  Value *getNewAccessOperand(ScopStmt &Stmt, const MemoryAccess &MA);
 
   /// @brief Generate the operand address
-  Value *generateLocationAccessed(const Instruction *Inst, const Value *Pointer,
-                                  ValueMapT &BBMap, ValueMapT &GlobalMap,
-                                  LoopToScevMapT &LTS);
+  Value *generateLocationAccessed(ScopStmt &Stmt, const Instruction *Inst,
+                                  const Value *Pointer, ValueMapT &BBMap,
+                                  ValueMapT &GlobalMap, LoopToScevMapT &LTS);
+
+  Value *generateScalarLoad(ScopStmt &Stmt, const LoadInst *load,
 
-  Value *generateScalarLoad(const LoadInst *load, ValueMapT &BBMap,
-                            ValueMapT &GlobalMap, LoopToScevMapT &LTS);
-
-  Value *generateScalarStore(const StoreInst *store, ValueMapT &BBMap,
-                             ValueMapT &GlobalMap, LoopToScevMapT &LTS);
+  Value *generateScalarStore(ScopStmt &Stmt, const StoreInst *store,
+                             ValueMapT &BBMap, ValueMapT &GlobalMap,
+                             LoopToScevMapT &LTS);
 
   /// @brief Copy a single Instruction.
   ///
   /// This copies a single Instruction and updates references to old values
   /// with references to new values, as defined by GlobalMap and BBMap.
   ///
   /// @param BBMap     A mapping from old values to their new values
   ///                  (for values recalculated within this basic block).
   /// @param GlobalMap A mapping from old values to their new values
   ///                  (for values recalculated in the new ScoP, but not
   ///                  within this basic block).
-  void copyInstruction(const Instruction *Inst, ValueMapT &BBMap,
-                       ValueMapT &GlobalMap, LoopToScevMapT &LTS);
+  void copyInstruction(ScopStmt &Stmt, const Instruction *Inst,
+                       ValueMapT &BBMap, ValueMapT &GlobalMap,
+                       LoopToScevMapT &LTS);
 
   /// @brief Copy the basic block.
   ///
   /// This copies the entire basic block and updates references to old values
   /// with references to new values, as defined by GlobalMap.
   ///
   /// @param GlobalMap A mapping from old values to their new values
   ///                  (for values recalculated in the new ScoP, but not
public:
   ///                   instructions.
   /// @param Schedule   A map from the statement to a schedule where the
   ///                   innermost dimension is the dimension of the innermost
   ///                   loop containing the statemenet.
   /// @param P          A reference to the pass this function is called from.
   ///                   The pass is needed to update other analysis.
   /// @param LI        The loop info for the current function
   /// @param SE        The scalar evolution info for the current function
-  /// @param Build       The AST build with the new schedule.
   /// @param ExprBuilder An expression builder to generate new access functions.
-  static void generate(PollyIRBuilder &B, ScopStmt &Stmt,
+  static void generate(BlockGenerator &BlockGen, ScopStmt &Stmt,
                        VectorValueMapT &GlobalMaps,
                        std::vector<LoopToScevMapT> &VLTS,
-                       __isl_keep isl_map *Schedule, Pass *P, LoopInfo &LI,
-                       ScalarEvolution &SE,
-                       __isl_keep isl_ast_build *Build = nullptr,
-                       IslExprBuilder *ExprBuilder = nullptr) {
-    VectorBlockGenerator Generator(B, GlobalMaps, VLTS, Stmt, Schedule, P, LI,
-                                   SE, Build, ExprBuilder);
-    Generator.copyBB();
+                       __isl_keep isl_map *Schedule) {
+    VectorBlockGenerator Generator(BlockGen, GlobalMaps, VLTS, Schedule);
+    Generator.copyBB(Stmt);
   }
 
 private:
   // This is a vector of global value maps.  The first map is used for the first
   // vector lane, ...
   // Each map, contains information about Instructions in the old ScoP, which
   // are recalculated in the new SCoP. When copying the basic block, we replace
   // all referenes to the old instructions with their recalculated values.
private:
   //   "outer loop in the old loop nest" -> SCEV("c2 + lane + 3"),
   //   "inner loop in the old loop nest" -> SCEV("c1").
   std::vector<LoopToScevMapT> &VLTS;
 
   // A map from the statement to a schedule where the innermost dimension is the
   // dimension of the innermost loop containing the statemenet.
   isl_map *Schedule;
 
-  VectorBlockGenerator(PollyIRBuilder &B, VectorValueMapT &GlobalMaps,
-                       std::vector<LoopToScevMapT> &VLTS, ScopStmt &Stmt,
-                       __isl_keep isl_map *Schedule, Pass *P, LoopInfo &LI,
-                       ScalarEvolution &SE,
-                       __isl_keep isl_ast_build *Build = nullptr,
-                       IslExprBuilder *ExprBuilder = nullptr);
+  VectorBlockGenerator(BlockGenerator &BlockGen, VectorValueMapT &GlobalMaps,
+                       std::vector<LoopToScevMapT> &VLTS,
+                       __isl_keep isl_map *Schedule);
 
   int getVectorWidth();
 
-  Value *getVectorValue(const Value *Old, ValueMapT &VectorMap,
+  Value *getVectorValue(ScopStmt &Stmt, const Value *Old, ValueMapT &VectorMap,
                         VectorValueMapT &ScalarMaps, Loop *L);
 
   Type *getVectorPtrTy(const Value *V, int Width);
 
   /// @brief Load a vector from a set of adjacent scalars
   ///
   /// In case a set of scalars is known to be next to each other in memory,
   /// create a vector load that loads those scalars
   ///
   /// %vector_ptr= bitcast double* %p to <4 x double>*
   /// %vec_full = load <4 x double>* %vector_ptr
   ///
   /// @param NegativeStride This is used to indicate a -1 stride. In such
   ///                       a case we load the end of a base address and
   ///                       shuffle the accesses in reverse order into the
   ///                       vector. By default we would do only positive
   ///                       strides.
   ///
-  Value *generateStrideOneLoad(const LoadInst *Load,
+  Value *generateStrideOneLoad(ScopStmt &Stmt, const LoadInst *Load,
                                VectorValueMapT &ScalarMaps,
                                bool NegativeStride);
 
   /// @brief Load a vector initialized from a single scalar in memory
   ///
   /// In case all elements of a vector are initialized to the same
   /// scalar value, this value is loaded and shuffeled into all elements
   /// of the vector.
   ///
   /// %splat_one = load <1 x double>* %p
   /// %splat = shufflevector <1 x double> %splat_one, <1 x
   ///       double> %splat_one, <4 x i32> zeroinitializer
   ///
-  Value *generateStrideZeroLoad(const LoadInst *Load, ValueMapT &BBMap);
+  Value *generateStrideZeroLoad(ScopStmt &Stmt, const LoadInst *Load,
+                                ValueMapT &BBMap);
 
   /// @brief Load a vector from scalars distributed in memory
   ///
   /// In case some scalars a distributed randomly in memory. Create a vector
   /// by loading each scalar and by inserting one after the other into the
   /// vector.
   ///
   /// %scalar_1= load double* %p_1
   /// %vec_1 = insertelement <2 x double> undef, double %scalar_1, i32 0
   /// %scalar 2 = load double* %p_2
   /// %vec_2 = insertelement <2 x double> %vec_1, double %scalar_1, i32 1
   ///
-  Value *generateUnknownStrideLoad(const LoadInst *Load,
+  Value *generateUnknownStrideLoad(ScopStmt &Stmt, const LoadInst *Load,
                                    VectorValueMapT &ScalarMaps);
 
-  void generateLoad(const LoadInst *Load, ValueMapT &VectorMap,
+  void generateLoad(ScopStmt &Stmt, const LoadInst *Load, ValueMapT &VectorMap,
                     VectorValueMapT &ScalarMaps);
 
-  void copyUnaryInst(const UnaryInstruction *Inst, ValueMapT &VectorMap,
-                     VectorValueMapT &ScalarMaps);
+  void copyUnaryInst(ScopStmt &Stmt, const UnaryInstruction *Inst,
+                     ValueMapT &VectorMap, VectorValueMapT &ScalarMaps);
 
-  void copyBinaryInst(const BinaryOperator *Inst, ValueMapT &VectorMap,
-                      VectorValueMapT &ScalarMaps);
+  void copyBinaryInst(ScopStmt &Stmt, const BinaryOperator *Inst,
+                      ValueMapT &VectorMap, VectorValueMapT &ScalarMaps);
 
-  void copyStore(const StoreInst *Store, ValueMapT &VectorMap,
+  void copyStore(ScopStmt &Stmt, const StoreInst *Store, ValueMapT &VectorMap,
                  VectorValueMapT &ScalarMaps);
 
-  void copyInstScalarized(const Instruction *Inst, ValueMapT &VectorMap,
-                          VectorValueMapT &ScalarMaps);
+  void copyInstScalarized(ScopStmt &Stmt, const Instruction *Inst,
+                          ValueMapT &VectorMap, VectorValueMapT &ScalarMaps);
 
   bool extractScalarValues(const Instruction *Inst, ValueMapT &VectorMap,
                            VectorValueMapT &ScalarMaps);
 
   bool hasVectorOperands(const Instruction *Inst, ValueMapT &VectorMap);
 
-  void copyInstruction(const Instruction *Inst, ValueMapT &VectorMap,
-                       VectorValueMapT &ScalarMaps);
+  void copyInstruction(ScopStmt &Stmt, const Instruction *Inst,
+                       ValueMapT &VectorMap, VectorValueMapT &ScalarMaps);
 
-  void copyBB();
+  void copyBB(ScopStmt &Stmt);
 };
 }
 #endif

include/polly/ScopInfo.h

 struct isl_ctx;
 struct isl_map;
 struct isl_basic_map;
 struct isl_id;
 struct isl_set;
 struct isl_union_set;
 struct isl_union_map;
 struct isl_space;
+struct isl_ast_build;
 struct isl_constraint;
 struct isl_pw_multi_aff;
 
 namespace polly {
 
 class IRAccess;
 class Scop;
 class ScopStmt;
class ScopStmt {
   MemoryAccessVec MemAccs;
   std::map<const Instruction *, MemoryAccess *> InstructionToAccess;
 
   //@}
 
   /// The BasicBlock represented by this statement.
   BasicBlock *BB;
 
+  /// @brief The isl AST build for the new generated AST.
+  isl_ast_build *Build;
+
   std::vector<Loop *> NestLoops;
 
   std::string BaseName;
 
   /// Build the statement.
   //@{
   __isl_give isl_set *buildConditionSet(const Comparison &Cmp);
   __isl_give isl_set *addConditionsToDomain(__isl_take isl_set *Domain,
public:
   unsigned getNumIterators() const;
   unsigned getNumScattering() const;
 
   Scop *getParent() { return &Parent; }
   const Scop *getParent() const { return &Parent; }
 
   const char *getBaseName() const;
 
+  /// @brief Set the isl AST build.
+  void setAstBuild(__isl_keep isl_ast_build *B) { Build = B; }
+
+  /// @brief Get the isl AST build.
+  __isl_keep isl_ast_build *getAstBuild() const { return Build; }
+
   /// @brief Restrict the domain of the statement.
   ///
   /// @param NewDomain The new statement domain.
   void restrictDomain(__isl_take isl_set *NewDomain);
 
   /// @brief Get the loop for a dimension.
   ///
   /// @param Dimension The dimension of the induction variable

lib/Analysis/ScopInfo.cpp

void ScopStmt::deriveAssumptions() {
   for (Instruction &Inst : *BB)
     if (auto *GEP = dyn_cast<GetElementPtrInst>(&Inst))
       deriveAssumptionsFromGEP(GEP);
 }
 
 ScopStmt::ScopStmt(Scop &parent, TempScop &tempScop, const Region &CurRegion,
                    BasicBlock &bb, SmallVectorImpl<Loop *> &Nest,
                    SmallVectorImpl<unsigned> &Scatter)
-    : Parent(parent), BB(&bb), NestLoops(Nest.size()) {
+    : Parent(parent), BB(&bb), Build(nullptr), NestLoops(Nest.size()) {
   // Setup the induction variables.
   for (unsigned i = 0, e = Nest.size(); i < e; ++i)
     NestLoops[i] = Nest[i];
 
   BaseName = getIslCompatibleName("Stmt_", &bb, "");
 
   Domain = buildDomain(tempScop, CurRegion);
   buildScattering(Scatter);

lib/CodeGen/BlockGenerators.cpp

case llvm::Intrinsic::expect:
       return true;
     default:
       break;
     }
   }
   return false;
 }
 
-BlockGenerator::BlockGenerator(PollyIRBuilder &B, ScopStmt &Stmt, Pass *P,
-                               LoopInfo &LI, ScalarEvolution &SE,
-                               isl_ast_build *Build,
-                               IslExprBuilder *ExprBuilder)
-    : Builder(B), Statement(Stmt), P(P), LI(LI), SE(SE), Build(Build),
-      ExprBuilder(ExprBuilder) {}
-
-Value *BlockGenerator::getNewValue(const Value *Old, ValueMapT &BBMap,
-                                   ValueMapT &GlobalMap, LoopToScevMapT &LTS,
-                                   Loop *L) const {
+BlockGenerator::BlockGenerator(PollyIRBuilder &B, Pass *P, LoopInfo &LI,
+                               ScalarEvolution &SE, IslExprBuilder *ExprBuilder)
+    : Builder(B), P(P), LI(LI), SE(SE), ExprBuilder(ExprBuilder),
+      EntryBB(B.GetInsertBlock()->getParent()->getEntryBlock()) {}
+
+Value *BlockGenerator::getNewValue(ScopStmt &Stmt, const Value *Old,
+                                   ValueMapT &BBMap, ValueMapT &GlobalMap,
+                                   LoopToScevMapT &LTS, Loop *L) const {
   // We assume constants never change.
   // This avoids map lookups for many calls to this function.
   if (isa<Constant>(Old))
     return const_cast<Value *>(Old);
 
   if (Value *New = GlobalMap.lookup(Old)) {
     if (Old->getType()->getScalarSizeInBits() <
         New->getType()->getScalarSizeInBits())
if (SE.isSCEVable(Old->getType()))
     }
 
   // A scop-constant value defined by a global or a function parameter.
   if (isa<GlobalValue>(Old) || isa<Argument>(Old))
     return const_cast<Value *>(Old);
 
   // A scop-constant value defined by an instruction executed outside the scop.
   if (const Instruction *Inst = dyn_cast<Instruction>(Old))
-    if (!Statement.getParent()->getRegion().contains(Inst->getParent()))
+    if (!Stmt.getParent()->getRegion().contains(Inst->getParent()))
       return const_cast<Value *>(Old);
 
   // The scalar dependence is neither available nor SCEVCodegenable.
   llvm_unreachable("Unexpected scalar dependence in region!");
   return nullptr;
 }
 
-void BlockGenerator::copyInstScalar(const Instruction *Inst, ValueMapT &BBMap,
-                                    ValueMapT &GlobalMap, LoopToScevMapT &LTS) {
+void BlockGenerator::copyInstScalar(ScopStmt &Stmt, const Instruction *Inst,
+                                    ValueMapT &BBMap, ValueMapT &GlobalMap,
+                                    LoopToScevMapT &LTS) {
   // We do not generate debug intrinsics as we did not investigate how to
   // copy them correctly. At the current state, they just crash the code
   // generation as the meta-data operands are not correctly copied.
   if (isa<DbgInfoIntrinsic>(Inst))
     return;
 
   Instruction *NewInst = Inst->clone();
 
   // Replace old operands with the new ones.
   for (Value *OldOperand : Inst->operands()) {
-    Value *NewOperand =
-        getNewValue(OldOperand, BBMap, GlobalMap, LTS, getLoopForInst(Inst));
+    Value *NewOperand = getNewValue(Stmt, OldOperand, BBMap, GlobalMap, LTS,
+                                    getLoopForInst(Inst));
 
     if (!NewOperand) {
       assert(!isa<StoreInst>(NewInst) &&
              "Store instructions are always needed!");
       delete NewInst;
       return;
     }
 
     NewInst->replaceUsesOfWith(OldOperand, NewOperand);
   }
 
   Builder.Insert(NewInst);
   BBMap[Inst] = NewInst;
 
   if (!NewInst->getType()->isVoidTy())
     NewInst->setName("p_" + Inst->getName());
 }
 
-Value *BlockGenerator::getNewAccessOperand(const MemoryAccess &MA) {
+Value *BlockGenerator::getNewAccessOperand(ScopStmt &Stmt,
+                                           const MemoryAccess &MA) {
   isl_pw_multi_aff *PWAccRel;
   isl_union_map *Schedule;
   isl_ast_expr *Expr;
+  isl_ast_build *Build = Stmt.getAstBuild();
 
   assert(ExprBuilder && Build &&
          "Cannot generate new value without IslExprBuilder!");
 
   Schedule = isl_ast_build_get_schedule(Build);
   PWAccRel = MA.applyScheduleToAccessRelation(Schedule);
 
   Expr = isl_ast_build_access_from_pw_multi_aff(Build, PWAccRel);
   Expr = isl_ast_expr_address_of(Expr);
 
   return ExprBuilder->create(Expr);
 }
 
-Value *BlockGenerator::generateLocationAccessed(const Instruction *Inst,
-                                                const Value *Pointer,
-                                                ValueMapT &BBMap,
-                                                ValueMapT &GlobalMap,
-                                                LoopToScevMapT &LTS) {
-  const MemoryAccess &MA = Statement.getAccessFor(Inst);
+Value *BlockGenerator::generateLocationAccessed(
+    ScopStmt &Stmt, const Instruction *Inst, const Value *Pointer,
+    ValueMapT &BBMap, ValueMapT &GlobalMap, LoopToScevMapT &LTS) {
+  const MemoryAccess &MA = Stmt.getAccessFor(Inst);
 
   Value *NewPointer;
   if (MA.hasNewAccessRelation())
-    NewPointer = getNewAccessOperand(MA);
+    NewPointer = getNewAccessOperand(Stmt, MA);
   else
     NewPointer =
-        getNewValue(Pointer, BBMap, GlobalMap, LTS, getLoopForInst(Inst));
+        getNewValue(Stmt, Pointer, BBMap, GlobalMap, LTS, getLoopForInst(Inst));
 
   return NewPointer;
 }
 
 Loop *BlockGenerator::getLoopForInst(const llvm::Instruction *Inst) {
   return LI.getLoopFor(Inst->getParent());
 }
 
-Value *BlockGenerator::generateScalarLoad(const LoadInst *Load,
+Value *BlockGenerator::generateScalarLoad(ScopStmt &Stmt, const LoadInst *Load,
                                           ValueMapT &BBMap,
                                           ValueMapT &GlobalMap,
                                           LoopToScevMapT &LTS) {
   const Value *Pointer = Load->getPointerOperand();
   Value *NewPointer =
-      generateLocationAccessed(Load, Pointer, BBMap, GlobalMap, LTS);
+      generateLocationAccessed(Stmt, Load, Pointer, BBMap, GlobalMap, LTS);
   Value *ScalarLoad = Builder.CreateAlignedLoad(
       NewPointer, Load->getAlignment(), Load->getName() + "_p_scalar_");
   return ScalarLoad;
 }
 
-Value *BlockGenerator::generateScalarStore(const StoreInst *Store,
+Value *BlockGenerator::generateScalarStore(ScopStmt &Stmt,
+                                           const StoreInst *Store,
                                            ValueMapT &BBMap,
                                            ValueMapT &GlobalMap,
                                            LoopToScevMapT &LTS) {
   const Value *Pointer = Store->getPointerOperand();
   Value *NewPointer =
-      generateLocationAccessed(Store, Pointer, BBMap, GlobalMap, LTS);
-  Value *ValueOperand = getNewValue(Store->getValueOperand(), BBMap, GlobalMap,
-                                    LTS, getLoopForInst(Store));
+      generateLocationAccessed(Stmt, Store, Pointer, BBMap, GlobalMap, LTS);
+  Value *ValueOperand = getNewValue(Stmt, Store->getValueOperand(), BBMap,
+                                    GlobalMap, LTS, getLoopForInst(Store));
 
   Value *NewStore = Builder.CreateAlignedStore(ValueOperand, NewPointer,
                                                Store->getAlignment());
   return NewStore;
 }
 
-void BlockGenerator::copyInstruction(const Instruction *Inst, ValueMapT &BBMap,
-                                     ValueMapT &GlobalMap,
+void BlockGenerator::copyInstruction(ScopStmt &Stmt, const Instruction *Inst,
+                                     ValueMapT &BBMap, ValueMapT &GlobalMap,
                                      LoopToScevMapT &LTS) {
   // Terminator instructions control the control flow. They are explicitly
   // expressed in the clast and do not need to be copied.
   if (Inst->isTerminator())
     return;
 
   if (canSynthesize(Inst, &P->getAnalysis<LoopInfoWrapperPass>().getLoopInfo(),
-                    &SE, &Statement.getParent()->getRegion()))
+                    &SE, &Stmt.getParent()->getRegion()))
     return;
 
   if (const LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
-    Value *NewLoad = generateScalarLoad(Load, BBMap, GlobalMap, LTS);
+    Value *NewLoad = generateScalarLoad(Stmt, Load, BBMap, GlobalMap, LTS);
     // Compute NewLoad before its insertion in BBMap to make the insertion
     // deterministic.
     BBMap[Load] = NewLoad;
     return;
   }
 
   if (const StoreInst *Store = dyn_cast<StoreInst>(Inst)) {
-    Value *NewStore = generateScalarStore(Store, BBMap, GlobalMap, LTS);
+    Value *NewStore = generateScalarStore(Stmt, Store, BBMap, GlobalMap, LTS);
     // Compute NewStore before its insertion in BBMap to make the insertion
     // deterministic.
     BBMap[Store] = NewStore;
     return;
   }
 
   // Skip some special intrinsics for which we do not adjust the semantics to
   // the new schedule. All others are handled like every other instruction.
if (auto *IT = dyn_cast<IntrinsicInst>(Inst)) {
     case llvm::Intrinsic::expect:
       return;
     default:
       // Other intrinsics are copied.
       break;
     }
   }
 
-  copyInstScalar(Inst, BBMap, GlobalMap, LTS);
+  copyInstScalar(Stmt, Inst, BBMap, GlobalMap, LTS);
 }
 
-void BlockGenerator::copyBB(ValueMapT &GlobalMap, LoopToScevMapT &LTS) {
+void BlockGenerator::copyBB(ScopStmt &Stmt, ValueMapT &GlobalMap,
+                            LoopToScevMapT &LTS) {
   auto *DTWP = P->getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
   auto *LIWP = P->getAnalysisIfAvailable<LoopInfoWrapperPass>();
   auto *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
 
-  BasicBlock *BB = Statement.getBasicBlock();
+  BasicBlock *BB = Stmt.getBasicBlock();
   BasicBlock *CopyBB =
       SplitBlock(Builder.GetInsertBlock(), Builder.GetInsertPoint(), DT, LI);
   CopyBB->setName("polly.stmt." + BB->getName());
   Builder.SetInsertPoint(CopyBB->begin());
 
   ValueMapT BBMap;
 
   for (Instruction &Inst : *BB)
-    copyInstruction(&Inst, BBMap, GlobalMap, LTS);
+    copyInstruction(Stmt, &Inst, BBMap, GlobalMap, LTS);
 }
 
-VectorBlockGenerator::VectorBlockGenerator(
-    PollyIRBuilder &B, VectorValueMapT &GlobalMaps,
-    std::vector<LoopToScevMapT> &VLTS, ScopStmt &Stmt,
-    __isl_keep isl_map *Schedule, Pass *P, LoopInfo &LI, ScalarEvolution &SE,
-    __isl_keep isl_ast_build *Build, IslExprBuilder *ExprBuilder)
-    : BlockGenerator(B, Stmt, P, LI, SE, Build, ExprBuilder),
-      GlobalMaps(GlobalMaps), VLTS(VLTS), Schedule(Schedule) {
+VectorBlockGenerator::VectorBlockGenerator(BlockGenerator &BlockGen,
+                                           VectorValueMapT &GlobalMaps,
+                                           std::vector<LoopToScevMapT> &VLTS,
+                                           isl_map *Schedule)
+    : BlockGenerator(BlockGen), GlobalMaps(GlobalMaps), VLTS(VLTS),
+      Schedule(Schedule) {
   assert(GlobalMaps.size() > 1 && "Only one vector lane found");
   assert(Schedule && "No statement domain provided");
 }
 
-Value *VectorBlockGenerator::getVectorValue(const Value *Old,
+Value *VectorBlockGenerator::getVectorValue(ScopStmt &Stmt, const Value *Old,
                                             ValueMapT &VectorMap,
                                             VectorValueMapT &ScalarMaps,
                                             Loop *L) {
   if (Value *NewValue = VectorMap.lookup(Old))
     return NewValue;
 
   int Width = getVectorWidth();
 
   Value *Vector = UndefValue::get(VectorType::get(Old->getType(), Width));
 
   for (int Lane = 0; Lane < Width; Lane++)
     Vector = Builder.CreateInsertElement(
-        Vector,
-        getNewValue(Old, ScalarMaps[Lane], GlobalMaps[Lane], VLTS[Lane], L),
+        Vector, getNewValue(Stmt, Old, ScalarMaps[Lane], GlobalMaps[Lane],
+                            VLTS[Lane], L),
         Builder.getInt32(Lane));
 
   VectorMap[Old] = Vector;
 
   return Vector;
 }
 
 Type *VectorBlockGenerator::getVectorPtrTy(const Value *Val, int Width) {
   PointerType *PointerTy = dyn_cast<PointerType>(Val->getType());
   assert(PointerTy && "PointerType expected");
 
   Type *ScalarType = PointerTy->getElementType();
   VectorType *VectorType = VectorType::get(ScalarType, Width);
 
   return PointerType::getUnqual(VectorType);
 }
 
-Value *
-VectorBlockGenerator::generateStrideOneLoad(const LoadInst *Load,
-                                            VectorValueMapT &ScalarMaps,
-                                            bool NegativeStride = false) {
+Value *VectorBlockGenerator::generateStrideOneLoad(
+    ScopStmt &Stmt, const LoadInst *Load, VectorValueMapT &ScalarMaps,
   unsigned VectorWidth = getVectorWidth();
   const Value *Pointer = Load->getPointerOperand();
   Type *VectorPtrType = getVectorPtrTy(Pointer, VectorWidth);
   unsigned Offset = NegativeStride ? VectorWidth - 1 : 0;
 
   Value *NewPointer = nullptr;
-  NewPointer = generateLocationAccessed(Load, Pointer, ScalarMaps[Offset],
+  NewPointer = generateLocationAccessed(Stmt, Load, Pointer, ScalarMaps[Offset],
                                         GlobalMaps[Offset], VLTS[Offset]);
   Value *VectorPtr =
       Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
   LoadInst *VecLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_vec_full");
   if (!Aligned)
     VecLoad->setAlignment(8);
 
   if (NegativeStride) {
     SmallVector<Constant *, 16> Indices;
     for (int i = VectorWidth - 1; i >= 0; i--)
       Indices.push_back(ConstantInt::get(Builder.getInt32Ty(), i));
     Constant *SV = llvm::ConstantVector::get(Indices);
     Value *RevVecLoad = Builder.CreateShuffleVector(
         VecLoad, VecLoad, SV, Load->getName() + "_reverse");
     return RevVecLoad;
   }
 
   return VecLoad;
 }
 
-Value *VectorBlockGenerator::generateStrideZeroLoad(const LoadInst *Load,
+Value *VectorBlockGenerator::generateStrideZeroLoad(ScopStmt &Stmt,
+                                                    const LoadInst *Load,
                                                     ValueMapT &BBMap) {
   const Value *Pointer = Load->getPointerOperand();
   Type *VectorPtrType = getVectorPtrTy(Pointer, 1);
-  Value *NewPointer =
-      generateLocationAccessed(Load, Pointer, BBMap, GlobalMaps[0], VLTS[0]);
+  Value *NewPointer = generateLocationAccessed(Stmt, Load, Pointer, BBMap,
+                                               GlobalMaps[0], VLTS[0]);
   Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
                                            Load->getName() + "_p_vec_p");
   LoadInst *ScalarLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_splat_one");
 
   if (!Aligned)
     ScalarLoad->setAlignment(8);
 
   Constant *SplatVector = Constant::getNullValue(
       VectorType::get(Builder.getInt32Ty(), getVectorWidth()));
 
   Value *VectorLoad = Builder.CreateShuffleVector(
       ScalarLoad, ScalarLoad, SplatVector, Load->getName() + "_p_splat");
   return VectorLoad;
 }
 
-Value *
-VectorBlockGenerator::generateUnknownStrideLoad(const LoadInst *Load,
-                                                VectorValueMapT &ScalarMaps) {
+Value *VectorBlockGenerator::generateUnknownStrideLoad(
+    ScopStmt &Stmt, const LoadInst *Load, VectorValueMapT &ScalarMaps) {
   int VectorWidth = getVectorWidth();
   const Value *Pointer = Load->getPointerOperand();
   VectorType *VectorType = VectorType::get(
       dyn_cast<PointerType>(Pointer->getType())->getElementType(), VectorWidth);
 
   Value *Vector = UndefValue::get(VectorType);
 
   for (int i = 0; i < VectorWidth; i++) {
-    Value *NewPointer = generateLocationAccessed(Load, Pointer, ScalarMaps[i],
-                                                 GlobalMaps[i], VLTS[i]);
+    Value *NewPointer = generateLocationAccessed(
+        Stmt, Load, Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
     Value *ScalarLoad =
         Builder.CreateLoad(NewPointer, Load->getName() + "_p_scalar_");
     Vector = Builder.CreateInsertElement(
         Vector, ScalarLoad, Builder.getInt32(i), Load->getName() + "_p_vec_");
   }
 
   return Vector;
 }
 
-void VectorBlockGenerator::generateLoad(const LoadInst *Load,
+void VectorBlockGenerator::generateLoad(ScopStmt &Stmt, const LoadInst *Load,
                                         ValueMapT &VectorMap,
                                         VectorValueMapT &ScalarMaps) {
   if (PollyVectorizerChoice >= VECTORIZER_FIRST_NEED_GROUPED_UNROLL ||
       !VectorType::isValidElementType(Load->getType())) {
     for (int i = 0; i < getVectorWidth(); i++)
       ScalarMaps[i][Load] =
-          generateScalarLoad(Load, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
+          generateScalarLoad(Stmt, Load, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
     return;
   }
 
-  const MemoryAccess &Access = Statement.getAccessFor(Load);
+  const MemoryAccess &Access = Stmt.getAccessFor(Load);
 
   // Make sure we have scalar values available to access the pointer to
   // the data location.
   extractScalarValues(Load, VectorMap, ScalarMaps);
 
   Value *NewLoad;
   if (Access.isStrideZero(isl_map_copy(Schedule)))
-    NewLoad = generateStrideZeroLoad(Load, ScalarMaps[0]);
+    NewLoad = generateStrideZeroLoad(Stmt, Load, ScalarMaps[0]);
   else if (Access.isStrideOne(isl_map_copy(Schedule)))
-    NewLoad = generateStrideOneLoad(Load, ScalarMaps);
+    NewLoad = generateStrideOneLoad(Stmt, Load, ScalarMaps);
   else if (Access.isStrideX(isl_map_copy(Schedule), -1))
-    NewLoad = generateStrideOneLoad(Load, ScalarMaps, true);
+    NewLoad = generateStrideOneLoad(Stmt, Load, ScalarMaps, true);
   else
-    NewLoad = generateUnknownStrideLoad(Load, ScalarMaps);
+    NewLoad = generateUnknownStrideLoad(Stmt, Load, ScalarMaps);
 
   VectorMap[Load] = NewLoad;
 }
 
-void VectorBlockGenerator::copyUnaryInst(const UnaryInstruction *Inst,
+void VectorBlockGenerator::copyUnaryInst(ScopStmt &Stmt,
+                                         const UnaryInstruction *Inst,
                                          ValueMapT &VectorMap,
                                          VectorValueMapT &ScalarMaps) {
   int VectorWidth = getVectorWidth();
-  Value *NewOperand = getVectorValue(Inst->getOperand(0), VectorMap, ScalarMaps,
-                                     getLoopForInst(Inst));
+  Value *NewOperand = getVectorValue(Stmt, Inst->getOperand(0), VectorMap,
+                                     ScalarMaps, getLoopForInst(Inst));
 
   assert(isa<CastInst>(Inst) && "Can not generate vector code for instruction");
 
   const CastInst *Cast = dyn_cast<CastInst>(Inst);
   VectorType *DestType = VectorType::get(Inst->getType(), VectorWidth);
   VectorMap[Inst] = Builder.CreateCast(Cast->getOpcode(), NewOperand, DestType);
 }
 
-void VectorBlockGenerator::copyBinaryInst(const BinaryOperator *Inst,
+void VectorBlockGenerator::copyBinaryInst(ScopStmt &Stmt,
+                                          const BinaryOperator *Inst,
                                           ValueMapT &VectorMap,
                                           VectorValueMapT &ScalarMaps) {
   Loop *L = getLoopForInst(Inst);
   Value *OpZero = Inst->getOperand(0);
   Value *OpOne = Inst->getOperand(1);
 
   Value *NewOpZero, *NewOpOne;
-  NewOpZero = getVectorValue(OpZero, VectorMap, ScalarMaps, L);
-  NewOpOne = getVectorValue(OpOne, VectorMap, ScalarMaps, L);
+  NewOpZero = getVectorValue(Stmt, OpZero, VectorMap, ScalarMaps, L);
+  NewOpOne = getVectorValue(Stmt, OpOne, VectorMap, ScalarMaps, L);
 
   Value *NewInst = Builder.CreateBinOp(Inst->getOpcode(), NewOpZero, NewOpOne,
                                        Inst->getName() + "p_vec");
   VectorMap[Inst] = NewInst;
 }
 
-void VectorBlockGenerator::copyStore(const StoreInst *Store,
+void VectorBlockGenerator::copyStore(ScopStmt &Stmt, const StoreInst *Store,
                                      ValueMapT &VectorMap,
                                      VectorValueMapT &ScalarMaps) {
-  const MemoryAccess &Access = Statement.getAccessFor(Store);
+  const MemoryAccess &Access = Stmt.getAccessFor(Store);
 
   const Value *Pointer = Store->getPointerOperand();
-  Value *Vector = getVectorValue(Store->getValueOperand(), VectorMap,
+  Value *Vector = getVectorValue(Stmt, Store->getValueOperand(), VectorMap,
                                  ScalarMaps, getLoopForInst(Store));
 
   // Make sure we have scalar values available to access the pointer to
   // the data location.
   extractScalarValues(Store, VectorMap, ScalarMaps);
 
   if (Access.isStrideOne(isl_map_copy(Schedule))) {
     Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth());
-    Value *NewPointer = generateLocationAccessed(Store, Pointer, ScalarMaps[0],
-                                                 GlobalMaps[0], VLTS[0]);
+    Value *NewPointer = generateLocationAccessed(
+        Stmt, Store, Pointer, ScalarMaps[0], GlobalMaps[0], VLTS[0]);
 
     Value *VectorPtr =
         Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
     StoreInst *Store = Builder.CreateStore(Vector, VectorPtr);
 
     if (!Aligned)
       Store->setAlignment(8);
   } else {
     for (unsigned i = 0; i < ScalarMaps.size(); i++) {
       Value *Scalar = Builder.CreateExtractElement(Vector, Builder.getInt32(i));
       Value *NewPointer = generateLocationAccessed(
-          Store, Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
+          Stmt, Store, Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
       Builder.CreateStore(Scalar, NewPointer);
     }
   }
 }
 
 bool VectorBlockGenerator::hasVectorOperands(const Instruction *Inst,
                                              ValueMapT &VectorMap) {
   for (Value *Operand : Inst->operands())
for (int i = 0; i < VectorWidth; ++i) {
       SM[Operand] =
           Builder.CreateExtractElement(NewVector, Builder.getInt32(i));
     }
   }
 
   return HasVectorOperand;
 }
 
-void VectorBlockGenerator::copyInstScalarized(const Instruction *Inst,
+void VectorBlockGenerator::copyInstScalarized(ScopStmt &Stmt,
+                                              const Instruction *Inst,
                                               ValueMapT &VectorMap,
                                               VectorValueMapT &ScalarMaps) {
   bool HasVectorOperand;
   int VectorWidth = getVectorWidth();
 
   HasVectorOperand = extractScalarValues(Inst, VectorMap, ScalarMaps);
 
   for (int VectorLane = 0; VectorLane < getVectorWidth(); VectorLane++)
-    BlockGenerator::copyInstruction(Inst, ScalarMaps[VectorLane],
+    BlockGenerator::copyInstruction(Stmt, Inst, ScalarMaps[VectorLane],
                                     GlobalMaps[VectorLane], VLTS[VectorLane]);
 
   if (!VectorType::isValidElementType(Inst->getType()) || !HasVectorOperand)
     return;
 
   // Make the result available as vector value.
   VectorType *VectorType = VectorType::get(Inst->getType(), VectorWidth);
   Value *Vector = UndefValue::get(VectorType);
 
   for (int i = 0; i < VectorWidth; i++)
     Vector = Builder.CreateInsertElement(Vector, ScalarMaps[i][Inst],
                                          Builder.getInt32(i));
 
   VectorMap[Inst] = Vector;
 }
 
 int VectorBlockGenerator::getVectorWidth() { return GlobalMaps.size(); }
 
-void VectorBlockGenerator::copyInstruction(const Instruction *Inst,
+void VectorBlockGenerator::copyInstruction(ScopStmt &Stmt,
+                                           const Instruction *Inst,
                                            ValueMapT &VectorMap,
                                            VectorValueMapT &ScalarMaps) {
   // Terminator instructions control the control flow. They are explicitly
   // expressed in the clast and do not need to be copied.
   if (Inst->isTerminator())
     return;
 
   if (canSynthesize(Inst, &P->getAnalysis<LoopInfoWrapperPass>().getLoopInfo(),
-                    &SE, &Statement.getParent()->getRegion()))
+                    &SE, &Stmt.getParent()->getRegion()))
     return;
 
   if (const LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
-    generateLoad(Load, VectorMap, ScalarMaps);
+    generateLoad(Stmt, Load, VectorMap, ScalarMaps);
     return;
   }
 
   if (hasVectorOperands(Inst, VectorMap)) {
     if (const StoreInst *Store = dyn_cast<StoreInst>(Inst)) {
-      copyStore(Store, VectorMap, ScalarMaps);
+      copyStore(Stmt, Store, VectorMap, ScalarMaps);
       return;
     }
 
     if (const UnaryInstruction *Unary = dyn_cast<UnaryInstruction>(Inst)) {
-      copyUnaryInst(Unary, VectorMap, ScalarMaps);
+      copyUnaryInst(Stmt, Unary, VectorMap, ScalarMaps);
       return;
     }
 
     if (const BinaryOperator *Binary = dyn_cast<BinaryOperator>(Inst)) {
-      copyBinaryInst(Binary, VectorMap, ScalarMaps);
+      copyBinaryInst(Stmt, Binary, VectorMap, ScalarMaps);
       return;
     }
 
     // Falltrough: We generate scalar instructions, if we don't know how to
     // generate vector code.
   }
 
-  copyInstScalarized(Inst, VectorMap, ScalarMaps);
+  copyInstScalarized(Stmt, Inst, VectorMap, ScalarMaps);
 }
 
-void VectorBlockGenerator::copyBB() {
+void VectorBlockGenerator::copyBB(ScopStmt &Stmt) {
   auto *DTWP = P->getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
   auto *LIWP = P->getAnalysisIfAvailable<LoopInfoWrapperPass>();
   auto *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
 
-  BasicBlock *BB = Statement.getBasicBlock();
+  BasicBlock *BB = Stmt.getBasicBlock();
   BasicBlock *CopyBB =
       SplitBlock(Builder.GetInsertBlock(), Builder.GetInsertPoint(), DT, LI);
   CopyBB->setName("polly.stmt." + BB->getName());
   Builder.SetInsertPoint(CopyBB->begin());
 
   // Create two maps that store the mapping from the original instructions of
   // the old basic block to their copies in the new basic block. Those maps
   // are basic block local.
   //
   // As vector code generation is supported there is one map for scalar values
   // and one for vector values.
   //
   // In case we just do scalar code generation, the vectorMap is not used and
   // the scalarMap has just one dimension, which contains the mapping.
   //
   // In case vector code generation is done, an instruction may either appear
   // in the vector map once (as it is calculating >vectorwidth< values at a
   // time. Or (if the values are calculated using scalar operations), it
   // appears once in every dimension of the scalarMap.
   VectorValueMapT ScalarBlockMap(getVectorWidth());
   ValueMapT VectorBlockMap;
 
   for (Instruction &Inst : *BB)
-    copyInstruction(&Inst, VectorBlockMap, ScalarBlockMap);
+    copyInstruction(Stmt, &Inst, VectorBlockMap, ScalarBlockMap);
 }

lib/CodeGen/IslCodeGeneration.cpp

 
 class IslNodeBuilder {
 public:
   IslNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator, Pass *P,
                  const DataLayout &DL, LoopInfo &LI, ScalarEvolution &SE,
                  DominatorTree &DT, Scop &S)
       : S(S), Builder(Builder), Annotator(Annotator),
         Rewriter(new SCEVExpander(SE, "polly")),
-        ExprBuilder(Builder, IDToValue, *Rewriter), P(P), DL(DL), LI(LI),
+        ExprBuilder(Builder, IDToValue, *Rewriter),
+        BlockGen(Builder, P, LI, SE, &ExprBuilder), P(P), DL(DL), LI(LI),
         SE(SE), DT(DT) {}
 
   ~IslNodeBuilder() { delete Rewriter; }
 
   void addParameters(__isl_take isl_set *Context);
   void create(__isl_take isl_ast_node *Node);
   IslExprBuilder &getExprBuilder() { return ExprBuilder; }
 
 private:
   Scop &S;
   PollyIRBuilder &Builder;
   ScopAnnotator &Annotator;
 
   /// @brief A SCEVExpander to create llvm values from SCEVs.
   SCEVExpander *Rewriter;
 
   IslExprBuilder ExprBuilder;
+  BlockGenerator BlockGen;
   Pass *P;
   const DataLayout &DL;
   LoopInfo &LI;
   ScalarEvolution &SE;
   DominatorTree &DT;
 
   /// @brief The current iteration of out-of-scop loops
   ///
void IslNodeBuilder::createUserVector(__isl_take isl_ast_node *User,
                                       std::vector<Value *> &IVS,
                                       __isl_take isl_id *IteratorID,
                                       __isl_take isl_union_map *Schedule) {
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(User);
   isl_ast_expr *StmtExpr = isl_ast_expr_get_op_arg(Expr, 0);
   isl_id *Id = isl_ast_expr_get_id(StmtExpr);
   isl_ast_expr_free(StmtExpr);
   ScopStmt *Stmt = (ScopStmt *)isl_id_get_user(Id);
+  Stmt->setAstBuild(IslAstInfo::getBuild(User));
   VectorValueMapT VectorMap(IVS.size());
   std::vector<LoopToScevMapT> VLTS(IVS.size());
 
   isl_union_set *Domain = isl_union_set_from_set(Stmt->getDomain());
   Schedule = isl_union_map_intersect_domain(Schedule, Domain);
   isl_map *S = isl_map_from_union_map(Schedule);
 
   createSubstitutionsVector(Expr, Stmt, VectorMap, VLTS, IVS, IteratorID);
-  VectorBlockGenerator::generate(Builder, *Stmt, VectorMap, VLTS, S, P, LI, SE,
-                                 IslAstInfo::getBuild(User), &ExprBuilder);
+  VectorBlockGenerator::generate(BlockGen, *Stmt, VectorMap, VLTS, S);
 
   isl_map_free(S);
   isl_id_free(Id);
   isl_ast_node_free(User);
 }
 
 void IslNodeBuilder::createForVector(__isl_take isl_ast_node *For,
                                      int VectorWidth) {
void IslNodeBuilder::createUser(__isl_take isl_ast_node *User) {
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(User);
   isl_ast_expr *StmtExpr = isl_ast_expr_get_op_arg(Expr, 0);
   Id = isl_ast_expr_get_id(StmtExpr);
   isl_ast_expr_free(StmtExpr);
 
   LTS.insert(OutsideLoopIterations.begin(), OutsideLoopIterations.end());
 
   Stmt = (ScopStmt *)isl_id_get_user(Id);
+  Stmt->setAstBuild(IslAstInfo::getBuild(User));
 
   createSubstitutions(Expr, Stmt, VMap, LTS);
-  BlockGenerator::generate(Builder, *Stmt, VMap, LTS, P, LI, SE,
-                           IslAstInfo::getBuild(User), &ExprBuilder);
+  BlockGen.copyBB(*Stmt, VMap, LTS);
 
   isl_ast_node_free(User);
   isl_id_free(Id);
 }
 
 void IslNodeBuilder::createBlock(__isl_take isl_ast_node *Block) {
   isl_ast_node_list *List = isl_ast_node_block_get_children(Block);