Remove isNew from getOrCreateAlloca

[grosser]

Summary

As we already model external (escaping uses) as explicit memory accesses and
the block builder generates scalar stores for all memory accesses, all scalar
values inside a basic block should already be initialized when generating
escape values. Hence, isNew will always be false and the corresponding code
path is never executed. This change passes both 'make check-polly' as well as
LNT.

Johannes, do you remember why you introduced this code path? Did I miss
something? If so, could you provide a test case that would fail with this
patch applied?

[jdoerfert]

I think if we model each espacing value as a write in the SCoP this patch is fine.

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

protected:
   /// @brief Return the alloca for @p ScalarBase in @p Map.
   ///
   /// If no alloca was mapped to @p ScalarBase in @p Map a new one is created
   /// and named after @p ScalarBase with the suffix @p NameExt.
   ///
   /// @param ScalarBase The demoted scalar value.
   /// @param Map        The map we should look for a mapped alloca value.
   /// @param NameExt    The suffix we add to the name of a new created alloca.
-  /// @param IsNew      If set it will hold true iff the alloca was created.
   ///
   /// @returns The alloca for @p ScalarBase in @p Map.
   AllocaInst *getOrCreateAlloca(Value *ScalarBase, ScalarAllocaMapTy &Map,
-                                const char *NameExt = ".s2a",
-                                bool *IsNew = nullptr);
+                                const char *NameExt);
 
   /// @brief Generate reload of scalars demoted to memory and needed by @p Inst.
   ///
   /// @param Stmt  The statement we generate code for.
   /// @param Inst  The instruction that might need reloaded values.
   /// @param BBMap A mapping from old values to their new values in this block.
   virtual void generateScalarLoads(ScopStmt &Stmt, const Instruction *Inst,
                                    ValueMapT &BBMap);

polly/trunk/lib/CodeGen/BlockGenerators.cpp

void BlockGenerator::copyBB(ScopStmt &Stmt, BasicBlock *BB, BasicBlock *CopyBB,
 
   const Region &R = Stmt.getParent()->getRegion();
   for (Instruction &Inst : *BB)
     handleOutsideUsers(R, &Inst, BBMap[&Inst]);
 }
 
 AllocaInst *BlockGenerator::getOrCreateAlloca(Value *ScalarBase,
                                               ScalarAllocaMapTy &Map,
-                                              const char *NameExt,
-                                              bool *IsNew) {
-
+                                              const char *NameExt) {
   // Check if an alloca was cached for the base instruction.
   AllocaInst *&Addr = Map[ScalarBase];
 
-  // If needed indicate if it was found already or will be created.
-  if (IsNew)
-    *IsNew = (Addr == nullptr);
-
   // If no alloca was found create one and insert it in the entry block.
   if (!Addr) {
     auto *Ty = ScalarBase->getType();
     Addr = new AllocaInst(Ty, ScalarBase->getName() + NameExt);
     Addr->insertBefore(EntryBB->getFirstInsertionPt());
   }
 
   return Addr;

 }
 
 AllocaInst *BlockGenerator::getOrCreatePHIAlloca(Value *ScalarBase) {
   return getOrCreateAlloca(ScalarBase, PHIOpMap, ".phiops");
 }
 
 void BlockGenerator::handleOutsideUsers(const Region &R, Instruction *Inst,
                                         Value *InstCopy) {
-  // If there are escape users we get the alloca for this instruction and put
-  // it in the EscapeMap for later finalization. However, if the alloca was not
-  // created by an already handled scalar dependence we have to initialize it
-  // also. Lastly, if the instruction was copied multiple times we already did
-  // this and can exit.
+  // If there are escape users we get the alloca for this instruction and put it
+  // in the EscapeMap for later finalization. Lastly, if the instruction was
+  // copied multiple times we already did this and can exit.
   if (EscapeMap.count(Inst))
     return;
 
   EscapeUserVectorTy EscapeUsers;
   for (User *U : Inst->users()) {
 
     // Non-instruction user will never escape.
     Instruction *UI = dyn_cast<Instruction>(U);
     if (!UI)
       continue;
 
     if (R.contains(UI))
       continue;
 
     EscapeUsers.push_back(UI);
   }
 
   // Exit if no escape uses were found.
   if (EscapeUsers.empty())
     return;
 
   // Get or create an escape alloca for this instruction.
-  bool IsNew;
-  AllocaInst *ScalarAddr =
-      getOrCreateAlloca(Inst, ScalarMap, ".escape", &IsNew);
+  AllocaInst *ScalarAddr = getOrCreateScalarAlloca(Inst);
 
   // Remember that this instruction has escape uses and the escape alloca.
   EscapeMap[Inst] = std::make_pair(ScalarAddr, std::move(EscapeUsers));
-
-  // If the escape alloca was just created store the instruction in there,
-  // otherwise that happened already.
-  if (IsNew) {
-    assert(InstCopy && "Except PHIs every instruction should have a copy!");
-    Builder.CreateStore(InstCopy, ScalarAddr);
-  }
 }
 
 void BlockGenerator::generateScalarLoads(ScopStmt &Stmt,
                                          const Instruction *Inst,
                                          ValueMapT &BBMap) {
   auto *MAL = Stmt.lookupAccessesFor(Inst);
 
   if (!MAL)