Revert "[OpenMP] Codegen aggregate for outlined function captures"

This reverts commit e9c7291.

Fix failing tests

Author: ggeorgakoudis

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -1284,7 +1284,7 @@ static llvm::Function *emitParallelOrTeamsOutlinedFunction(
   CGOpenMPOutlinedRegionInfo CGInfo(*CS, ThreadIDVar, CodeGen, InnermostKind,
                                     HasCancel, OutlinedHelperName);
   CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
-  return CGF.GenerateOpenMPCapturedStmtFunctionAggregate(*CS, D.getBeginLoc());
+  return CGF.GenerateOpenMPCapturedStmtFunction(*CS, D.getBeginLoc());
 }
 
 llvm::Function *CGOpenMPRuntime::emitParallelOutlinedFunction(

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

@@ -1513,56 +1513,21 @@ void CGOpenMPRuntimeGPU::emitParallelCall(CodeGenFunction &CGF,
     // TODO: Is that needed?
     CodeGenFunction::OMPPrivateScope PrivateArgScope(CGF);
 
-    // Store addresses of global arguments to pass to the parallel call.
     Address CapturedVarsAddrs = CGF.CreateDefaultAlignTempAlloca(
         llvm::ArrayType::get(CGM.VoidPtrTy, CapturedVars.size()),
         "captured_vars_addrs");
-
-    // Store globalized values to push, pop through the global stack.
-    SmallVector<llvm::Value *, 4> GlobalValues;
+    // There's something to share.
     if (!CapturedVars.empty()) {
+      // Prepare for parallel region. Indicate the outlined function.
       ASTContext &Ctx = CGF.getContext();
       unsigned Idx = 0;
       for (llvm::Value *V : CapturedVars) {
         Address Dst = Bld.CreateConstArrayGEP(CapturedVarsAddrs, Idx);
         llvm::Value *PtrV;
         if (V->getType()->isIntegerTy())
           PtrV = Bld.CreateIntToPtr(V, CGF.VoidPtrTy);
-        else {
-          assert(V->getType()->isPointerTy() &&
-                 "Expected Pointer Type to globalize.");
-          // Globalize and store pointer.
-          llvm::Type *PtrElemTy = V->getType()->getPointerElementType();
-          auto &DL = CGM.getDataLayout();
-          unsigned GlobalSize = DL.getTypeAllocSize(PtrElemTy);
-
-          /*
-              llvm::Value *AllocArgs[] = {CGF.getTypeSize(VD->getType())};
-              llvm::Instruction *VoidPtr =
-                  CGF.EmitRuntimeCall(OMPBuilder.getOrCreateRuntimeFunction(
-                                          CGM.getModule(),
-             OMPRTL___kmpc_alloc_shared), AllocArgs, VD->getName());
-          */
-          // Use shared memory to store globalized pointer values, for now this
-          // should be the outlined args aggregate struct.
-          llvm::Value *GlobalSizeArg[] = {
-              llvm::ConstantInt::get(CGM.SizeTy, GlobalSize)};
-          llvm::Value *GlobalValue = CGF.EmitRuntimeCall(
-              OMPBuilder.getOrCreateRuntimeFunction(CGM.getModule(),
-                                                    OMPRTL___kmpc_alloc_shared),
-              GlobalSizeArg);
-          GlobalValues.push_back(GlobalValue);
-
-          llvm::Value *CapturedVarVal = Bld.CreateAlignedLoad(
-              PtrElemTy, V, DL.getABITypeAlign(PtrElemTy));
-          llvm::Value *GlobalValueCast =
-              Bld.CreatePointerBitCastOrAddrSpaceCast(
-                  GlobalValue, PtrElemTy->getPointerTo());
-          Bld.CreateDefaultAlignedStore(CapturedVarVal, GlobalValueCast);
-
-          PtrV = Bld.CreatePointerBitCastOrAddrSpaceCast(GlobalValue,
-                                                         CGF.VoidPtrTy);
-        }
+        else
+          PtrV = Bld.CreatePointerBitCastOrAddrSpaceCast(V, CGF.VoidPtrTy);
         CGF.EmitStoreOfScalar(PtrV, Dst, /*Volatile=*/false,
                               Ctx.getPointerType(Ctx.VoidPtrTy));
         ++Idx;
@@ -1575,9 +1540,8 @@ void CGOpenMPRuntimeGPU::emitParallelCall(CodeGenFunction &CGF,
                                     /* isSigned */ false);
     else
       IfCondVal = llvm::ConstantInt::get(CGF.Int32Ty, 1);
-    assert(IfCondVal && "Expected a value");
 
-    // Create the parallel call.
+    assert(IfCondVal && "Expected a value");
     llvm::Value *RTLoc = emitUpdateLocation(CGF, Loc);
     llvm::Value *Args[] = {
         RTLoc,
@@ -1593,13 +1557,6 @@ void CGOpenMPRuntimeGPU::emitParallelCall(CodeGenFunction &CGF,
     CGF.EmitRuntimeCall(OMPBuilder.getOrCreateRuntimeFunction(
                             CGM.getModule(), OMPRTL___kmpc_parallel_51),
                         Args);
-
-    // Pop any globalized values from the global stack.
-    for (auto *V : GlobalValues) {
-      CGF.EmitRuntimeCall(OMPBuilder.getOrCreateRuntimeFunction(
-                              CGM.getModule(), OMPRTL___kmpc_free_shared),
-                          V);
-    }
   };
 
   RegionCodeGenTy RCG(ParallelGen);
@@ -3510,6 +3467,7 @@ llvm::Function *CGOpenMPRuntimeGPU::createParallelDataSharingWrapper(
                     D.getBeginLoc(), D.getBeginLoc());
 
   const auto *RD = CS.getCapturedRecordDecl();
+  auto CurField = RD->field_begin();
 
   Address ZeroAddr = CGF.CreateDefaultAlignTempAlloca(CGF.Int32Ty,
                                                       /*Name=*/".zero.addr");
@@ -3521,6 +3479,7 @@ llvm::Function *CGOpenMPRuntimeGPU::createParallelDataSharingWrapper(
   Args.emplace_back(ZeroAddr.getPointer());
 
   CGBuilderTy &Bld = CGF.Builder;
+  auto CI = CS.capture_begin();
 
   // Use global memory for data sharing.
   // Handle passing of global args to workers.
@@ -3567,27 +3526,23 @@ llvm::Function *CGOpenMPRuntimeGPU::createParallelDataSharingWrapper(
     ++Idx;
   }
   if (CS.capture_size() > 0) {
-    auto CI = CS.capture_begin();
-    // Load the outlined arg aggregate struct.
     ASTContext &CGFContext = CGF.getContext();
-    QualType RecordPointerTy =
-        CGFContext.getPointerType(CGFContext.getRecordType(RD));
-    Address Src = Bld.CreateConstInBoundsGEP(SharedArgListAddress, Idx);
-    Address TypedAddress = Bld.CreatePointerBitCastOrAddrSpaceCast(
-        Src, CGF.ConvertTypeForMem(CGFContext.getPointerType(RecordPointerTy)));
-    llvm::Value *Arg = CGF.EmitLoadOfScalar(
-        TypedAddress,
-        /*Volatile=*/false, CGFContext.getPointerType(RecordPointerTy),
-        CI->getLocation());
-    Args.emplace_back(Arg);
-  } else {
-    // If there are no captured arguments, use nullptr.
-    ASTContext &CGFContext = CGF.getContext();
-    QualType RecordPointerTy =
-        CGFContext.getPointerType(CGFContext.getRecordType(RD));
-    llvm::Value *Arg =
-        llvm::Constant::getNullValue(CGF.ConvertTypeForMem(RecordPointerTy));
-    Args.emplace_back(Arg);
+    for (unsigned I = 0, E = CS.capture_size(); I < E; ++I, ++CI, ++CurField) {
+      QualType ElemTy = CurField->getType();
+      Address Src = Bld.CreateConstInBoundsGEP(SharedArgListAddress, I + Idx);
+      Address TypedAddress = Bld.CreatePointerBitCastOrAddrSpaceCast(
+          Src, CGF.ConvertTypeForMem(CGFContext.getPointerType(ElemTy)));
+      llvm::Value *Arg = CGF.EmitLoadOfScalar(TypedAddress,
+                                              /*Volatile=*/false,
+                                              CGFContext.getPointerType(ElemTy),
+                                              CI->getLocation());
+      if (CI->capturesVariableByCopy() &&
+          !CI->getCapturedVar()->getType()->isAnyPointerType()) {
+        Arg = castValueToType(CGF, Arg, ElemTy, CGFContext.getUIntPtrType(),
+                              CI->getLocation());
+      }
+      Args.emplace_back(Arg);
+    }
   }
 
   emitOutlinedFunctionCall(CGF, D.getBeginLoc(), OutlinedParallelFn, Args);

clang/lib/CodeGen/CGStmtOpenMP.cpp

@@ -320,32 +320,6 @@ llvm::Value *CodeGenFunction::getTypeSize(QualType Ty) {
   return CGM.getSize(SizeInChars);
 }
 
-void CodeGenFunction::GenerateOpenMPCapturedVarsAggregate(
-    const CapturedStmt &S, SmallVectorImpl<llvm::Value *> &CapturedVars) {
-  const RecordDecl *RD = S.getCapturedRecordDecl();
-  QualType RecordTy = getContext().getRecordType(RD);
-  // Create the aggregate argument struct for the outlined function.
-  LValue AggLV = MakeAddrLValue(
-      CreateMemTemp(RecordTy, "omp.outlined.arg.agg."), RecordTy);
-
-  // Initialize the aggregate with captured values.
-  auto CurField = RD->field_begin();
-  for (CapturedStmt::const_capture_init_iterator I = S.capture_init_begin(),
-                                                 E = S.capture_init_end();
-       I != E; ++I, ++CurField) {
-    LValue LV = EmitLValueForFieldInitialization(AggLV, *CurField);
-    // Initialize for VLA.
-    if (CurField->hasCapturedVLAType()) {
-      EmitLambdaVLACapture(CurField->getCapturedVLAType(), LV);
-    } else
-      // Initialize for capturesThis, capturesVariableByCopy,
-      // capturesVariable
-      EmitInitializerForField(*CurField, LV, *I);
-  }
-
-  CapturedVars.push_back(AggLV.getPointer(*this));
-}
-
 void CodeGenFunction::GenerateOpenMPCapturedVars(
     const CapturedStmt &S, SmallVectorImpl<llvm::Value *> &CapturedVars) {
   const RecordDecl *RD = S.getCapturedRecordDecl();
@@ -446,101 +420,6 @@ struct FunctionOptions {
 };
 } // namespace
 
-static llvm::Function *emitOutlinedFunctionPrologueAggregate(
-    CodeGenFunction &CGF, FunctionArgList &Args,
-    llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>>
-        &LocalAddrs,
-    llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>>
-        &VLASizes,
-    llvm::Value *&CXXThisValue, const CapturedStmt &CS, SourceLocation Loc,
-    StringRef FunctionName) {
-  const CapturedDecl *CD = CS.getCapturedDecl();
-  const RecordDecl *RD = CS.getCapturedRecordDecl();
-  assert(CD->hasBody() && "missing CapturedDecl body");
-
-  CXXThisValue = nullptr;
-  // Build the argument list.
-  CodeGenModule &CGM = CGF.CGM;
-  ASTContext &Ctx = CGM.getContext();
-  Args.append(CD->param_begin(), CD->param_end());
-
-  // Create the function declaration.
-  const CGFunctionInfo &FuncInfo =
-      CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
-  llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
-
-  auto *F =
-      llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
-                             FunctionName, &CGM.getModule());
-  CGM.SetInternalFunctionAttributes(CD, F, FuncInfo);
-  if (CD->isNothrow())
-    F->setDoesNotThrow();
-  F->setDoesNotRecurse();
-
-  // Generate the function.
-  CGF.StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, Loc, Loc);
-  Address ContextAddr = CGF.GetAddrOfLocalVar(CD->getContextParam());
-  llvm::Value *ContextV = CGF.Builder.CreateLoad(ContextAddr);
-  LValue ContextLV = CGF.MakeNaturalAlignAddrLValue(
-      ContextV, CGM.getContext().getTagDeclType(RD));
-  auto I = CS.captures().begin();
-  for (const FieldDecl *FD : RD->fields()) {
-    LValue FieldLV = CGF.EmitLValueForFieldInitialization(ContextLV, FD);
-    // Do not map arguments if we emit function with non-original types.
-    Address LocalAddr = FieldLV.getAddress(CGF);
-    // If we are capturing a pointer by copy we don't need to do anything, just
-    // use the value that we get from the arguments.
-    if (I->capturesVariableByCopy() && FD->getType()->isAnyPointerType()) {
-      const VarDecl *CurVD = I->getCapturedVar();
-      LocalAddrs.insert({FD, {CurVD, LocalAddr}});
-      ++I;
-      continue;
-    }
-
-    LValue ArgLVal =
-        CGF.MakeAddrLValue(LocalAddr, FD->getType(), AlignmentSource::Decl);
-    if (FD->hasCapturedVLAType()) {
-      llvm::Value *ExprArg = CGF.EmitLoadOfScalar(ArgLVal, I->getLocation());
-      const VariableArrayType *VAT = FD->getCapturedVLAType();
-      VLASizes.try_emplace(FD, VAT->getSizeExpr(), ExprArg);
-    } else if (I->capturesVariable()) {
-      const VarDecl *Var = I->getCapturedVar();
-      QualType VarTy = Var->getType();
-      Address ArgAddr = ArgLVal.getAddress(CGF);
-      if (ArgLVal.getType()->isLValueReferenceType()) {
-        ArgAddr = CGF.EmitLoadOfReference(ArgLVal);
-      } else if (!VarTy->isVariablyModifiedType() || !VarTy->isPointerType()) {
-        assert(ArgLVal.getType()->isPointerType());
-        ArgAddr = CGF.EmitLoadOfPointer(
-            ArgAddr, ArgLVal.getType()->castAs<PointerType>());
-      }
-      LocalAddrs.insert(
-          {FD, {Var, Address(ArgAddr.getPointer(), Ctx.getDeclAlign(Var))}});
-    } else if (I->capturesVariableByCopy()) {
-      assert(!FD->getType()->isAnyPointerType() &&
-             "Not expecting a captured pointer.");
-      const VarDecl *Var = I->getCapturedVar();
-      Address CopyAddr = CGF.CreateMemTemp(FD->getType(), Ctx.getDeclAlign(FD),
-                                           Var->getName());
-      LValue CopyLVal =
-          CGF.MakeAddrLValue(CopyAddr, FD->getType(), AlignmentSource::Decl);
-
-      RValue ArgRVal = CGF.EmitLoadOfLValue(ArgLVal, I->getLocation());
-      CGF.EmitStoreThroughLValue(ArgRVal, CopyLVal);
-
-      LocalAddrs.insert({FD, {Var, CopyAddr}});
-    } else {
-      // If 'this' is captured, load it into CXXThisValue.
-      assert(I->capturesThis());
-      CXXThisValue = CGF.EmitLoadOfScalar(ArgLVal, I->getLocation());
-      LocalAddrs.insert({FD, {nullptr, ArgLVal.getAddress(CGF)}});
-    }
-    ++I;
-  }
-
-  return F;
-}
-
 static llvm::Function *emitOutlinedFunctionPrologue(
     CodeGenFunction &CGF, FunctionArgList &Args,
     llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>>
@@ -716,37 +595,6 @@ static llvm::Function *emitOutlinedFunctionPrologue(
   return F;
 }
 
-llvm::Function *CodeGenFunction::GenerateOpenMPCapturedStmtFunctionAggregate(
-    const CapturedStmt &S, SourceLocation Loc) {
-  assert(
-      CapturedStmtInfo &&
-      "CapturedStmtInfo should be set when generating the captured function");
-  const CapturedDecl *CD = S.getCapturedDecl();
-  // Build the argument list.
-  FunctionArgList Args;
-  llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>> LocalAddrs;
-  llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>> VLASizes;
-  StringRef FunctionName = CapturedStmtInfo->getHelperName();
-  llvm::Function *F = emitOutlinedFunctionPrologueAggregate(
-      *this, Args, LocalAddrs, VLASizes, CXXThisValue, S, Loc, FunctionName);
-  CodeGenFunction::OMPPrivateScope LocalScope(*this);
-  for (const auto &LocalAddrPair : LocalAddrs) {
-    if (LocalAddrPair.second.first) {
-      LocalScope.addPrivate(LocalAddrPair.second.first, [&LocalAddrPair]() {
-        return LocalAddrPair.second.second;
-      });
-    }
-  }
-  (void)LocalScope.Privatize();
-  for (const auto &VLASizePair : VLASizes)
-    VLASizeMap[VLASizePair.second.first] = VLASizePair.second.second;
-  PGO.assignRegionCounters(GlobalDecl(CD), F);
-  CapturedStmtInfo->EmitBody(*this, CD->getBody());
-  (void)LocalScope.ForceCleanup();
-  FinishFunction(CD->getBodyRBrace());
-  return F;
-}
-
 llvm::Function *
 CodeGenFunction::GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S,
                                                     SourceLocation Loc) {
@@ -1737,7 +1585,7 @@ static void emitCommonOMPParallelDirective(
   // The following lambda takes care of appending the lower and upper bound
   // parameters when necessary
   CodeGenBoundParameters(CGF, S, CapturedVars);
-  CGF.GenerateOpenMPCapturedVarsAggregate(*CS, CapturedVars);
+  CGF.GenerateOpenMPCapturedVars(*CS, CapturedVars);
   CGF.CGM.getOpenMPRuntime().emitParallelCall(CGF, S.getBeginLoc(), OutlinedFn,
                                               CapturedVars, IfCond);
 }
@@ -6205,7 +6053,7 @@ static void emitCommonOMPTeamsDirective(CodeGenFunction &CGF,
 
   OMPTeamsScope Scope(CGF, S);
   llvm::SmallVector<llvm::Value *, 16> CapturedVars;
-  CGF.GenerateOpenMPCapturedVarsAggregate(*CS, CapturedVars);
+  CGF.GenerateOpenMPCapturedVars(*CS, CapturedVars);
   CGF.CGM.getOpenMPRuntime().emitTeamsCall(CGF, S, S.getBeginLoc(), OutlinedFn,
                                            CapturedVars);
 }

clang/lib/CodeGen/CodeGenFunction.h

@@ -3283,13 +3283,8 @@ class CodeGenFunction : public CodeGenTypeCache {
   llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
   llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
   Address GenerateCapturedStmtArgument(const CapturedStmt &S);
-  llvm::Function *
-  GenerateOpenMPCapturedStmtFunctionAggregate(const CapturedStmt &S,
-                                              SourceLocation Loc);
   llvm::Function *GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S,
                                                      SourceLocation Loc);
-  void GenerateOpenMPCapturedVarsAggregate(
-      const CapturedStmt &S, SmallVectorImpl<llvm::Value *> &CapturedVars);
   void GenerateOpenMPCapturedVars(const CapturedStmt &S,
                                   SmallVectorImpl<llvm::Value *> &CapturedVars);
   void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,

clang/test/CodeGenCXX/observe-noexcept.cpp

@@ -9,7 +9,7 @@ void ffcomplex (int a) {
 
   // CHECK: call { double, double } @__muldc3(double %{{.+}}, double %{{.+}}, double %{{.+}}, double %{{.+}})
   dc *= dc;
-  // CHECK: call {{.+}} @__kmpc_fork_call({{.+}} [[REGNAME1:@.*]] to void (i32*, i32*, ...)*), %struct.anon* %{{.+}})
+  // CHECK: call {{.+}} @__kmpc_fork_call({{.+}} [[REGNAME1:@.*]] to void (i32*, i32*, ...)*), { double, double }* %{{.+}})
   #pragma omp parallel
   {
     dc *= dc;
@@ -32,7 +32,7 @@ void foo(int a, int b) {
 
   void (*fptr)(void) noexcept = fnoexcp;
 
-  // CHECK: call {{.+}} @__kmpc_fork_call({{.+}} [[REGNAME2:@.*]] to void (i32*, i32*, ...)*), %struct.anon.0* %{{.+}})
+  // CHECK: call {{.+}} @__kmpc_fork_call({{.+}} [[REGNAME2:@.*]] to void (i32*, i32*, ...)*), void ()** %{{.+}})
   #pragma omp parallel
   {
     fptr();