[OPENMP] Fixed incorrect work with cleanups, NFC.

[ABataev]

Summary

Destructors are never called for cleanups, so we can't use SmallVector as a member.

[rjmccall]

LGTM. Good catch.

cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp

 }
 
 llvm::Value *CGOpenMPRuntime::getCriticalRegionLock(StringRef CriticalName) {
   llvm::Twine Name(".gomp_critical_user_", CriticalName);
   return getOrCreateInternalVariable(KmpCriticalNameTy, Name.concat(".var"));
 }
 
 namespace {
-class CallEndCleanup : public EHScopeStack::Cleanup {
+template <int N> class CallEndCleanup : public EHScopeStack::Cleanup {
 public:
   typedef ArrayRef<llvm::Value *> CleanupValuesTy;
+
 private:
   llvm::Value *Callee;
-  llvm::SmallVector<llvm::Value *, 8> Args;
+  llvm::Value *Args[N];
 
 public:
-  CallEndCleanup(llvm::Value *Callee, CleanupValuesTy Args)
-      : Callee(Callee), Args(Args.begin(), Args.end()) {}
+  CallEndCleanup(llvm::Value *Callee, CleanupValuesTy CleanupArgs)
+      : Callee(Callee) {
+    assert(CleanupArgs.size() == N);
+    for (unsigned i = 0; i < N; ++i) {
+      Args[i] = CleanupArgs[i];
+    }
+  }
   void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
     CGF.EmitRuntimeCall(Callee, Args);
   }
 };
 } // namespace
 
 void CGOpenMPRuntime::emitCriticalRegion(CodeGenFunction &CGF,
                                          StringRef CriticalName,
                                          const RegionCodeGenTy &CriticalOpGen,
                                          SourceLocation Loc) {
   // __kmpc_critical(ident_t *, gtid, Lock);
   // CriticalOpGen();
   // __kmpc_end_critical(ident_t *, gtid, Lock);
   // Prepare arguments and build a call to __kmpc_critical
   {
     CodeGenFunction::RunCleanupsScope Scope(CGF);
     llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc),
                            getCriticalRegionLock(CriticalName)};
     CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_critical), Args);
     // Build a call to __kmpc_end_critical
-    CGF.EHStack.pushCleanup<CallEndCleanup>(
+    CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(Args)>>(
         NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_critical),
         llvm::makeArrayRef(Args));
     emitInlinedDirective(CGF, CriticalOpGen);
   }
 }
 
 static void emitIfStmt(CodeGenFunction &CGF, llvm::Value *IfCond,
                        const RegionCodeGenTy &BodyOpGen) {
void CGOpenMPRuntime::emitMasterRegion(CodeGenFunction &CGF,
   //   __kmpc_end_master(ident_t *, gtid);
   // }
   // Prepare arguments and build a call to __kmpc_master
   llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc)};
   auto *IsMaster =
       CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_master), Args);
   emitIfStmt(CGF, IsMaster, [&](CodeGenFunction &CGF) -> void {
     CodeGenFunction::RunCleanupsScope Scope(CGF);
-    CGF.EHStack.pushCleanup<CallEndCleanup>(
+    CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(Args)>>(
         NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_master),
         llvm::makeArrayRef(Args));
     MasterOpGen(CGF);
   });
 }
 
 void CGOpenMPRuntime::emitTaskyieldCall(CodeGenFunction &CGF,
                                         SourceLocation Loc) {
CGF.Builder.CreateAlignedStore(CGF.Builder.getInt32(0), DidIt,
                                    DidIt->getAlignment());
   }
   // Prepare arguments and build a call to __kmpc_single
   llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc)};
   auto *IsSingle =
       CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_single), Args);
   emitIfStmt(CGF, IsSingle, [&](CodeGenFunction &CGF) -> void {
     CodeGenFunction::RunCleanupsScope Scope(CGF);
-    CGF.EHStack.pushCleanup<CallEndCleanup>(
+    CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(Args)>>(
         NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_single),
         llvm::makeArrayRef(Args));
     SingleOpGen(CGF);
     if (DidIt) {
       // did_it = 1;
       CGF.Builder.CreateAlignedStore(CGF.Builder.getInt32(1), DidIt,
                                      DidIt->getAlignment());
     }
void CGOpenMPRuntime::emitOrderedRegion(CodeGenFunction &CGF,
   // OrderedOpGen();
   // __kmpc_end_ordered(ident_t *, gtid);
   // Prepare arguments and build a call to __kmpc_ordered
   {
     CodeGenFunction::RunCleanupsScope Scope(CGF);
     llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc)};
     CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_ordered), Args);
     // Build a call to __kmpc_end_ordered
-    CGF.EHStack.pushCleanup<CallEndCleanup>(
+    CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(Args)>>(
         NormalAndEHCleanup, createRuntimeFunction(OMPRTL__kmpc_end_ordered),
         llvm::makeArrayRef(Args));
     emitInlinedDirective(CGF, OrderedOpGen);
   }
 }
 
 void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
                                       OpenMPDirectiveKind Kind) {
void CGOpenMPRuntime::emitTaskCall(
   auto &&ElseCodeGen =
       [this, &TaskArgs, ThreadID, NewTaskNewTaskTTy, TaskEntry](
           CodeGenFunction &CGF) {
         CodeGenFunction::RunCleanupsScope LocalScope(CGF);
         CGF.EmitRuntimeCall(
             createRuntimeFunction(OMPRTL__kmpc_omp_task_begin_if0), TaskArgs);
         // Build void __kmpc_omp_task_complete_if0(ident_t *, kmp_int32 gtid,
         // kmp_task_t *new_task);
-        CGF.EHStack.pushCleanup<CallEndCleanup>(
+        CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(TaskArgs)>>(
             NormalAndEHCleanup,
             createRuntimeFunction(OMPRTL__kmpc_omp_task_complete_if0),
             llvm::makeArrayRef(TaskArgs));
 
         // Call proxy_task_entry(gtid, new_task);
         llvm::Value *OutlinedFnArgs[] = {ThreadID, NewTaskNewTaskTTy};
         CGF.EmitCallOrInvoke(TaskEntry, OutlinedFnArgs);
       };
void CGOpenMPRuntime::emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
   {
     CodeGenFunction::RunCleanupsScope Scope(CGF);
     // Add emission of __kmpc_end_reduce{_nowait}(<loc>, <gtid>, &<lock>);
     llvm::Value *EndArgs[] = {
         IdentTLoc, // ident_t *<loc>
         ThreadId,  // i32 <gtid>
         Lock       // kmp_critical_name *&<lock>
     };
-    CGF.EHStack.pushCleanup<CallEndCleanup>(
+    CGF.EHStack.pushCleanup<CallEndCleanup<array_lengthof(EndArgs)>>(
         NormalAndEHCleanup,
         createRuntimeFunction(WithNowait ? OMPRTL__kmpc_end_reduce_nowait
                                          : OMPRTL__kmpc_end_reduce),
         llvm::makeArrayRef(EndArgs));
     for (auto *E : ReductionOps) {
       CGF.EmitIgnoredExpr(E);
     }
   }