[Polly] Put the parallel context into the function entry block

[jdoerfert]

Summary

We use lifetime markers to limit the actual life range.

[grosser]

No test case changes?

Otherwise LGTM

lib/CodeGen/LoopGenerators.cpp

296

I don't think this XXX is even needed. AFAIK clang will always allocate all stack space in the entry block.

[dpeixott]

Needs test case. Otherwise LGTM.

lib/CodeGen/LoopGenerators.cpp

177

Use cast<> instead of dyn_cast<> when you don't check for null return result.

302

Use cast<> instead of dyn_cast<>

[jdoerfert]

Added test and use DataLayout for best results

[jdoerfert]

Closed by commit rL219005 (authored by @jdoerfert).

lib/CodeGen/LoopGenerators.cpp

Value *ParallelLoopGenerator::createParallelLoop(
   // whereas the codegenForSequential function creates a <= comparison.
   UB = Builder.CreateAdd(UB, ConstantInt::get(IVType, 1));
 
   // Tell the runtime we start a parallel loop
   createCallSpawnThreads(SubFn, SubFnParam, LB, UB, Stride);
   Builder.CreateCall(SubFn, SubFnParam);
   createCallJoinThreads();
 
+  // Mark the end of the lifetime for the parameter struct
+  Type *Ty = Struct->getType();
+  ConstantInt *SizeOf = dyn_cast<ConstantInt>(ConstantExpr::getSizeOf(Ty));
+  Builder.CreateLifetimeEnd(Struct, SizeOf);
+
   return IV;
 }
 
 void ParallelLoopGenerator::createCallSpawnThreads(Value *SubFn,
                                                    Value *SubFnParam, Value *LB,
                                                    Value *UB, Value *Stride) {
   const std::string Name = "GOMP_parallel_loop_runtime_start";
 

 
 Value *
 ParallelLoopGenerator::storeValuesIntoStruct(SetVector<Value *> &Values) {
   SmallVector<Type *, 8> Members;
 
   for (Value *V : Values)
     Members.push_back(V->getType());
 
+  // We do not want to allocate the alloca inside any loop, thus we allocate it
+  // in the entry block of the function and use annotations to denote the actual
+  // live span (similar to clang).
+  //
+  // XXX: It might be necessary to allocate the struct explicitly in front of
+  //      the outermost loop surrounding the current insertion block in order
+  //      to prevent us from allocating stack space without actually using it.
+  //      For now we assume the annotations suffice to sink the allocas to the
+  //      most recent dominating basic block which is not part of a loop.
+  BasicBlock &EntryBB = Builder.GetInsertBlock()->getParent()->getEntryBlock();
+  Instruction *IP = EntryBB.getFirstInsertionPt();
   StructType *Ty = StructType::get(Builder.getContext(), Members);
-  Value *Struct =
-      new AllocaInst(Ty, 0, "polly.par.userContext", Builder.GetInsertPoint());
+  Value *Struct = new AllocaInst(Ty, 0, "polly.par.userContext", IP);
+
+  ConstantInt *SizeOf = dyn_cast<ConstantInt>(ConstantExpr::getSizeOf(Ty));
+  Builder.CreateLifetimeStart(Struct, SizeOf);
 
   for (unsigned i = 0; i < Values.size(); i++) {
     Value *Address = Builder.CreateStructGEP(Struct, i);
     Builder.CreateStore(Values[i], Address);
   }
 
   return Struct;
 }