createScalarInitialization: Always store PHI-node value

[grosser]

Summary

The current code really tries hard to use getNewScalarValue(), which checks if
not the original value, but a possible copy or demoted value needs to be stored.
In this calling context it seems, that we _always_ use the ScalarValue that
comes form the incoming PHI node, but never any other value. As also no test
cases fail, it seems right to just drop this call to getNewScalarValue and
remove the parameters that are not needed any more.

[jdoerfert]

I am unsure and haven't tested it but don't we have to go back if we want to support parallel code generation?

polly/trunk/include/polly/CodeGen/BlockGenerators.h

public:
   /// @returns The alloca for @p Access
   AllocaInst *getOrCreateAlloca(MemoryAccess &Access);
 
   /// @brief Finalize the code generation for the SCoP @p S.
   ///
   /// This will initialize and finalize the scalar variables we demoted during
   /// the code generation.
   ///
-  /// @see createScalarInitialization(Region &, ValueMapT &)
+  /// @see createScalarInitialization(Region &)
   /// @see createScalarFinalization(Region &)
-  void finalizeSCoP(Scop &S, ValueMapT &VMap);
+  void finalizeSCoP(Scop &S);
 
   /// @brief An empty destructor
   virtual ~BlockGenerator(){};
 
 protected:
   PollyIRBuilder &Builder;
   LoopInfo &LI;
   ScalarEvolution &SE;
protected:
   void handleOutsideUsers(const Region &R, Instruction *Inst, Value *InstCopy);
 
   /// @brief Initialize the memory of demoted scalars.
   ///
   /// If a PHI node was demoted and one of its predecessor blocks was outside
   /// the SCoP we need to initialize the memory cell we demoted the PHI into
   /// with the value corresponding to that predecessor. As a SCoP is a
   /// __single__ entry region there is at most one such predecessor.
-  void createScalarInitialization(Region &R, ValueMapT &VMap);
+  void createScalarInitialization(Region &R);
 
   /// @brief Promote the values of demoted scalars after the SCoP.
   ///
   /// If a scalar value was used outside the SCoP we need to promote the value
   /// stored in the memory cell allocated for that scalar and combine it with
   /// the original value in the non-optimized SCoP.
   void createScalarFinalization(Region &R);
 

polly/trunk/include/polly/CodeGen/IslNodeBuilder.h

public:
   virtual ~IslNodeBuilder() {}
 
   void addParameters(__isl_take isl_set *Context);
   void create(__isl_take isl_ast_node *Node);
 
   /// @brief Finalize code generation for the SCoP @p S.
   ///
   /// @see BlockGenerator::finalizeSCoP(Scop &S)
-  void finalizeSCoP(Scop &S) { BlockGen.finalizeSCoP(S, ValueMap); }
+  void finalizeSCoP(Scop &S) { BlockGen.finalizeSCoP(S); }
 
   IslExprBuilder &getExprBuilder() { return ExprBuilder; }
 
   /// @brief Get the associated block generator.
   ///
   /// @return A referecne to the associated block generator.
   BlockGenerator &getBlockGenerator() { return BlockGen; }
 

polly/trunk/lib/CodeGen/BlockGenerators.cpp

for (MemoryAccess *MA : Stmt) {
     Value *Val = MA->getAccessValue();
     auto *Address = getOrCreateAlloca(*MA);
 
     Val = getNewScalarValue(Val, R, ScalarMap, BBMap, GlobalMap);
     Builder.CreateStore(Val, Address);
   }
 }
 
-void BlockGenerator::createScalarInitialization(Region &R,
-                                                ValueMapT &GlobalMap) {
+void BlockGenerator::createScalarInitialization(Region &R) {
   // The split block __just before__ the region and optimized region.
   BasicBlock *SplitBB = R.getEnteringBlock();
   BranchInst *SplitBBTerm = cast<BranchInst>(SplitBB->getTerminator());
   assert(SplitBBTerm->getNumSuccessors() == 2 && "Bad region entering block!");
 
   // Get the start block of the __optimized__ region.
   BasicBlock *StartBB = SplitBBTerm->getSuccessor(0);
   if (StartBB == R.getEntry())
     StartBB = SplitBBTerm->getSuccessor(1);
 
   // For each PHI predecessor outside the region store the incoming operand
   // value prior to entering the optimized region.
   Builder.SetInsertPoint(StartBB->getTerminator());
 
-  ScalarAllocaMapTy EmptyMap;
   for (const auto &PHIOpMapping : PHIOpMap) {
     const PHINode *PHI = cast<PHINode>(PHIOpMapping.getFirst());
 
     // Check if this PHI has the split block as predecessor (that is the only
     // possible predecessor outside the SCoP).
     int idx = PHI->getBasicBlockIndex(SplitBB);
     if (idx < 0)
       continue;
 
     Value *ScalarValue = PHI->getIncomingValue(idx);
-    ScalarValue =
-        getNewScalarValue(ScalarValue, R, EmptyMap, GlobalMap, GlobalMap);
 
     // If the split block is the predecessor initialize the PHI operator alloca.
     Builder.CreateStore(ScalarValue, PHIOpMapping.getSecond());
   }
 }
 
 void BlockGenerator::createScalarFinalization(Region &R) {
   // The exit block of the __unoptimized__ region.
if (SE.isSCEVable(EscapeInst->getType()))
       SE.forgetValue(EscapeInst);
 
     // Replace all uses of the demoted instruction with the merge PHI.
     for (Instruction *EUser : EscapeUsers)
       EUser->replaceUsesOfWith(EscapeInst, MergePHI);
   }
 }
 
-void BlockGenerator::finalizeSCoP(Scop &S, ValueMapT &GlobalMap) {
-  createScalarInitialization(S.getRegion(), GlobalMap);
+void BlockGenerator::finalizeSCoP(Scop &S) {
+  createScalarInitialization(S.getRegion());
   createScalarFinalization(S.getRegion());
 }
 
 VectorBlockGenerator::VectorBlockGenerator(BlockGenerator &BlockGen,
                                            VectorValueMapT &GlobalMaps,
                                            std::vector<LoopToScevMapT> &VLTS,
                                            isl_map *Schedule)
     : BlockGenerator(BlockGen), GlobalMaps(GlobalMaps), VLTS(VLTS),