[clang] 4627cef - [OpenMP][OMPIRBuilder] Migrate emitOffloadingArraysArgument from clang
Jan Sjodin via cfe-commits
cfe-commits at lists.llvm.org
Fri Oct 7 05:04:04 PDT 2022
Author: Jan Sjodin
Date: 2022-10-07T07:03:03-05:00
New Revision: 4627cef1134f99f3802a5ebfe26188d2c66da22f
URL: https://github.com/llvm/llvm-project/commit/4627cef1134f99f3802a5ebfe26188d2c66da22f
DIFF: https://github.com/llvm/llvm-project/commit/4627cef1134f99f3802a5ebfe26188d2c66da22f.diff
LOG: [OpenMP][OMPIRBuilder] Migrate emitOffloadingArraysArgument from clang
This patch moves the emitOffloadingArraysArgument function and
supporting data structures to OpenMPIRBuilder. This will later be used
in flang as well. The TargetDataInfo class was split up into generic
information and clang-specific data, which remain in clang. Further
migration will be done in in the future.
Reviewed By: jdoerfert
Differential Revision: https://reviews.llvm.org/D134662
Added:
Modified:
clang/lib/CodeGen/CGOpenMPRuntime.cpp
clang/lib/CodeGen/CGOpenMPRuntime.h
llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
Removed:
################################################################################
diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
index 5bf0e0815111e..0260b4cdc1572 100644
--- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp
+++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
@@ -9442,7 +9442,7 @@ static void emitNonContiguousDescriptor(
DimsAddr, CGM.Int8PtrTy, CGM.Int8Ty);
llvm::Value *P = CGF.Builder.CreateConstInBoundsGEP2_32(
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.PointersArray, 0, I);
+ Info.RTArgs.PointersArray, 0, I);
Address PAddr(P, CGM.VoidPtrTy, CGF.getPointerAlign());
CGF.Builder.CreateStore(DAddr.getPointer(), PAddr);
++L;
@@ -9520,13 +9520,13 @@ static void emitOffloadingArrays(
Ctx.VoidPtrTy, PointerNumAP, nullptr, ArrayType::Normal,
/*IndexTypeQuals=*/0);
- Info.BasePointersArray =
+ Info.RTArgs.BasePointersArray =
CGF.CreateMemTemp(PointerArrayType, ".offload_baseptrs").getPointer();
- Info.PointersArray =
+ Info.RTArgs.PointersArray =
CGF.CreateMemTemp(PointerArrayType, ".offload_ptrs").getPointer();
Address MappersArray =
CGF.CreateMemTemp(PointerArrayType, ".offload_mappers");
- Info.MappersArray = MappersArray.getPointer();
+ Info.RTArgs.MappersArray = MappersArray.getPointer();
// If we don't have any VLA types or other types that require runtime
// evaluation, we can use a constant array for the map sizes, otherwise we
@@ -9555,7 +9555,7 @@ static void emitOffloadingArrays(
QualType SizeArrayType = Ctx.getConstantArrayType(
Int64Ty, PointerNumAP, nullptr, ArrayType::Normal,
/*IndexTypeQuals=*/0);
- Info.SizesArray =
+ Info.RTArgs.SizesArray =
CGF.CreateMemTemp(SizeArrayType, ".offload_sizes").getPointer();
} else {
auto *SizesArrayInit = llvm::ConstantArray::get(
@@ -9579,9 +9579,9 @@ static void emitOffloadingArrays(
CGM.getNaturalTypeAlignment(Ctx.getIntTypeForBitwidth(
/*DestWidth=*/64, /*Signed=*/false))),
CGF.getTypeSize(SizeArrayType));
- Info.SizesArray = Buffer.getPointer();
+ Info.RTArgs.SizesArray = Buffer.getPointer();
} else {
- Info.SizesArray = SizesArrayGbl;
+ Info.RTArgs.SizesArray = SizesArrayGbl;
}
}
@@ -9593,12 +9593,12 @@ static void emitOffloadingArrays(
CGM.getOpenMPRuntime().getName({"offload_maptypes"});
auto *MapTypesArrayGbl =
OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
- Info.MapTypesArray = MapTypesArrayGbl;
+ Info.RTArgs.MapTypesArray = MapTypesArrayGbl;
// The information types are only built if there is debug information
// requested.
if (CGM.getCodeGenOpts().getDebugInfo() == codegenoptions::NoDebugInfo) {
- Info.MapNamesArray = llvm::Constant::getNullValue(
+ Info.RTArgs.MapNamesArray = llvm::Constant::getNullValue(
llvm::Type::getInt8Ty(CGF.Builder.getContext())->getPointerTo());
} else {
auto fillInfoMap = [&](MappableExprsHandler::MappingExprInfo &MapExpr) {
@@ -9610,7 +9610,7 @@ static void emitOffloadingArrays(
CGM.getOpenMPRuntime().getName({"offload_mapnames"});
auto *MapNamesArrayGbl =
OMPBuilder.createOffloadMapnames(InfoMap, MapnamesName);
- Info.MapNamesArray = MapNamesArrayGbl;
+ Info.RTArgs.MapNamesArray = MapNamesArrayGbl;
}
// If there's a present map type modifier, it must not be applied to the end
@@ -9626,7 +9626,7 @@ static void emitOffloadingArrays(
if (EndMapTypesDiffer) {
MapTypesArrayGbl =
OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
- Info.MapTypesArrayEnd = MapTypesArrayGbl;
+ Info.RTArgs.MapTypesArrayEnd = MapTypesArrayGbl;
}
}
@@ -9634,7 +9634,7 @@ static void emitOffloadingArrays(
llvm::Value *BPVal = *CombinedInfo.BasePointers[I];
llvm::Value *BP = CGF.Builder.CreateConstInBoundsGEP2_32(
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.BasePointersArray, 0, I);
+ Info.RTArgs.BasePointersArray, 0, I);
BP = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
BP, BPVal->getType()->getPointerTo(/*AddrSpace=*/0));
Address BPAddr(BP, BPVal->getType(),
@@ -9649,7 +9649,7 @@ static void emitOffloadingArrays(
llvm::Value *PVal = CombinedInfo.Pointers[I];
llvm::Value *P = CGF.Builder.CreateConstInBoundsGEP2_32(
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.PointersArray, 0, I);
+ Info.RTArgs.PointersArray, 0, I);
P = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
P, PVal->getType()->getPointerTo(/*AddrSpace=*/0));
Address PAddr(P, PVal->getType(), Ctx.getTypeAlignInChars(Ctx.VoidPtrTy));
@@ -9658,7 +9658,7 @@ static void emitOffloadingArrays(
if (RuntimeSizes.test(I)) {
llvm::Value *S = CGF.Builder.CreateConstInBoundsGEP2_32(
llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs),
- Info.SizesArray,
+ Info.RTArgs.SizesArray,
/*Idx0=*/0,
/*Idx1=*/I);
Address SAddr(S, CGM.Int64Ty, Ctx.getTypeAlignInChars(Int64Ty));
@@ -9688,76 +9688,6 @@ static void emitOffloadingArrays(
emitNonContiguousDescriptor(CGF, CombinedInfo, Info);
}
-namespace {
-/// Additional arguments for emitOffloadingArraysArgument function.
-struct ArgumentsOptions {
- bool ForEndCall = false;
- ArgumentsOptions() = default;
- ArgumentsOptions(bool ForEndCall) : ForEndCall(ForEndCall) {}
-};
-} // namespace
-
-/// Emit the arguments to be passed to the runtime library based on the
-/// arrays of base pointers, pointers, sizes, map types, and mappers. If
-/// ForEndCall, emit map types to be passed for the end of the region instead of
-/// the beginning.
-static void emitOffloadingArraysArgument(
- CodeGenFunction &CGF, llvm::Value *&BasePointersArrayArg,
- llvm::Value *&PointersArrayArg, llvm::Value *&SizesArrayArg,
- llvm::Value *&MapTypesArrayArg, llvm::Value *&MapNamesArrayArg,
- llvm::Value *&MappersArrayArg, CGOpenMPRuntime::TargetDataInfo &Info,
- const ArgumentsOptions &Options = ArgumentsOptions()) {
- assert((!Options.ForEndCall || Info.separateBeginEndCalls()) &&
- "expected region end call to runtime only when end call is separate");
- CodeGenModule &CGM = CGF.CGM;
- if (Info.NumberOfPtrs) {
- BasePointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
- llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.BasePointersArray,
- /*Idx0=*/0, /*Idx1=*/0);
- PointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
- llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.PointersArray,
- /*Idx0=*/0,
- /*Idx1=*/0);
- SizesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
- llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs), Info.SizesArray,
- /*Idx0=*/0, /*Idx1=*/0);
- MapTypesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
- llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs),
- Options.ForEndCall && Info.MapTypesArrayEnd ? Info.MapTypesArrayEnd
- : Info.MapTypesArray,
- /*Idx0=*/0,
- /*Idx1=*/0);
-
- // Only emit the mapper information arrays if debug information is
- // requested.
- if (CGF.CGM.getCodeGenOpts().getDebugInfo() == codegenoptions::NoDebugInfo)
- MapNamesArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- else
- MapNamesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
- llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
- Info.MapNamesArray,
- /*Idx0=*/0,
- /*Idx1=*/0);
- // If there is no user-defined mapper, set the mapper array to nullptr to
- // avoid an unnecessary data privatization
- if (!Info.HasMapper)
- MappersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- else
- MappersArrayArg =
- CGF.Builder.CreatePointerCast(Info.MappersArray, CGM.VoidPtrPtrTy);
- } else {
- BasePointersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- PointersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- SizesArrayArg = llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());
- MapTypesArrayArg =
- llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());
- MapNamesArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- MappersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
- }
-}
-
/// Check for inner distribute directive.
static const OMPExecutableDirective *
getNestedDistributeDirective(ASTContext &Ctx, const OMPExecutableDirective &D) {
@@ -10479,25 +10409,26 @@ void CGOpenMPRuntime::emitTargetCall(
// weren't referenced within the construct.
MEHandler.generateAllInfo(CombinedInfo, MappedVarSet);
- TargetDataInfo Info;
+ CGOpenMPRuntime::TargetDataInfo Info;
// Fill up the arrays and create the arguments.
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder);
- emitOffloadingArraysArgument(
- CGF, Info.BasePointersArray, Info.PointersArray, Info.SizesArray,
- Info.MapTypesArray, Info.MapNamesArray, Info.MappersArray, Info,
- {/*ForEndCall=*/false});
+ bool EmitDebug =
+ CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
+ OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
+ EmitDebug,
+ /*ForEndCall=*/false);
InputInfo.NumberOfTargetItems = Info.NumberOfPtrs;
- InputInfo.BasePointersArray =
- Address(Info.BasePointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
- InputInfo.PointersArray =
- Address(Info.PointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
+ InputInfo.BasePointersArray = Address(Info.RTArgs.BasePointersArray,
+ CGF.VoidPtrTy, CGM.getPointerAlign());
+ InputInfo.PointersArray = Address(Info.RTArgs.PointersArray, CGF.VoidPtrTy,
+ CGM.getPointerAlign());
InputInfo.SizesArray =
- Address(Info.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
+ Address(Info.RTArgs.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
InputInfo.MappersArray =
- Address(Info.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
- MapTypesArray = Info.MapTypesArray;
- MapNamesArray = Info.MapNamesArray;
+ Address(Info.RTArgs.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
+ MapTypesArray = Info.RTArgs.MapTypesArray;
+ MapNamesArray = Info.RTArgs.MapNamesArray;
if (RequiresOuterTask)
CGF.EmitOMPTargetTaskBasedDirective(D, ThenGen, InputInfo);
else
@@ -11063,7 +10994,8 @@ void CGOpenMPRuntime::emitNumTeamsClause(CodeGenFunction &CGF,
void CGOpenMPRuntime::emitTargetDataCalls(
CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
- const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
+ const Expr *Device, const RegionCodeGenTy &CodeGen,
+ CGOpenMPRuntime::TargetDataInfo &Info) {
if (!CGF.HaveInsertPoint())
return;
@@ -11087,15 +11019,11 @@ void CGOpenMPRuntime::emitTargetDataCalls(
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder,
/*IsNonContiguous=*/true);
- llvm::Value *BasePointersArrayArg = nullptr;
- llvm::Value *PointersArrayArg = nullptr;
- llvm::Value *SizesArrayArg = nullptr;
- llvm::Value *MapTypesArrayArg = nullptr;
- llvm::Value *MapNamesArrayArg = nullptr;
- llvm::Value *MappersArrayArg = nullptr;
- emitOffloadingArraysArgument(CGF, BasePointersArrayArg, PointersArrayArg,
- SizesArrayArg, MapTypesArrayArg,
- MapNamesArrayArg, MappersArrayArg, Info);
+ llvm::OpenMPIRBuilder::TargetDataRTArgs RTArgs;
+ bool EmitDebug =
+ CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
+ OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, RTArgs, Info,
+ EmitDebug);
// Emit device ID if any.
llvm::Value *DeviceID = nullptr;
@@ -11115,12 +11043,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
llvm::Value *OffloadingArgs[] = {RTLoc,
DeviceID,
PointerNum,
- BasePointersArrayArg,
- PointersArrayArg,
- SizesArrayArg,
- MapTypesArrayArg,
- MapNamesArrayArg,
- MappersArrayArg};
+ RTArgs.BasePointersArray,
+ RTArgs.PointersArray,
+ RTArgs.SizesArray,
+ RTArgs.MapTypesArray,
+ RTArgs.MapNamesArray,
+ RTArgs.MappersArray};
CGF.EmitRuntimeCall(
OMPBuilder.getOrCreateRuntimeFunction(
CGM.getModule(), OMPRTL___tgt_target_data_begin_mapper),
@@ -11137,16 +11065,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
PrePostActionTy &) {
assert(Info.isValid() && "Invalid data environment closing arguments.");
- llvm::Value *BasePointersArrayArg = nullptr;
- llvm::Value *PointersArrayArg = nullptr;
- llvm::Value *SizesArrayArg = nullptr;
- llvm::Value *MapTypesArrayArg = nullptr;
- llvm::Value *MapNamesArrayArg = nullptr;
- llvm::Value *MappersArrayArg = nullptr;
- emitOffloadingArraysArgument(CGF, BasePointersArrayArg, PointersArrayArg,
- SizesArrayArg, MapTypesArrayArg,
- MapNamesArrayArg, MappersArrayArg, Info,
- {/*ForEndCall=*/true});
+ llvm::OpenMPIRBuilder::TargetDataRTArgs RTArgs;
+ bool EmitDebug =
+ CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
+ OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, RTArgs, Info,
+ EmitDebug,
+ /*ForEndCall=*/true);
// Emit device ID if any.
llvm::Value *DeviceID = nullptr;
@@ -11166,12 +11090,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
llvm::Value *OffloadingArgs[] = {RTLoc,
DeviceID,
PointerNum,
- BasePointersArrayArg,
- PointersArrayArg,
- SizesArrayArg,
- MapTypesArrayArg,
- MapNamesArrayArg,
- MappersArrayArg};
+ RTArgs.BasePointersArray,
+ RTArgs.PointersArray,
+ RTArgs.SizesArray,
+ RTArgs.MapTypesArray,
+ RTArgs.MapNamesArray,
+ RTArgs.MappersArray};
CGF.EmitRuntimeCall(
OMPBuilder.getOrCreateRuntimeFunction(
CGM.getModule(), OMPRTL___tgt_target_data_end_mapper),
@@ -11360,27 +11284,28 @@ void CGOpenMPRuntime::emitTargetDataStandAloneCall(
MappableExprsHandler MEHandler(D, CGF);
MEHandler.generateAllInfo(CombinedInfo);
- TargetDataInfo Info;
+ CGOpenMPRuntime::TargetDataInfo Info;
// Fill up the arrays and create the arguments.
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder,
/*IsNonContiguous=*/true);
bool RequiresOuterTask = D.hasClausesOfKind<OMPDependClause>() ||
D.hasClausesOfKind<OMPNowaitClause>();
- emitOffloadingArraysArgument(
- CGF, Info.BasePointersArray, Info.PointersArray, Info.SizesArray,
- Info.MapTypesArray, Info.MapNamesArray, Info.MappersArray, Info,
- {/*ForEndCall=*/false});
+ bool EmitDebug =
+ CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
+ OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
+ EmitDebug,
+ /*ForEndCall=*/false);
InputInfo.NumberOfTargetItems = Info.NumberOfPtrs;
- InputInfo.BasePointersArray =
- Address(Info.BasePointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
- InputInfo.PointersArray =
- Address(Info.PointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
+ InputInfo.BasePointersArray = Address(Info.RTArgs.BasePointersArray,
+ CGF.VoidPtrTy, CGM.getPointerAlign());
+ InputInfo.PointersArray = Address(Info.RTArgs.PointersArray, CGF.VoidPtrTy,
+ CGM.getPointerAlign());
InputInfo.SizesArray =
- Address(Info.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
+ Address(Info.RTArgs.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
InputInfo.MappersArray =
- Address(Info.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
- MapTypesArray = Info.MapTypesArray;
- MapNamesArray = Info.MapNamesArray;
+ Address(Info.RTArgs.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
+ MapTypesArray = Info.RTArgs.MapTypesArray;
+ MapNamesArray = Info.RTArgs.MapNamesArray;
if (RequiresOuterTask)
CGF.EmitOMPTargetTaskBasedDirective(D, ThenGen, InputInfo);
else
@@ -13075,7 +13000,8 @@ void CGOpenMPSIMDRuntime::emitNumTeamsClause(CodeGenFunction &CGF,
void CGOpenMPSIMDRuntime::emitTargetDataCalls(
CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
- const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
+ const Expr *Device, const RegionCodeGenTy &CodeGen,
+ CGOpenMPRuntime::TargetDataInfo &Info) {
llvm_unreachable("Not supported in SIMD-only mode");
}
diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.h b/clang/lib/CodeGen/CGOpenMPRuntime.h
index b95aef68335ed..3eb29e262ff1f 100644
--- a/clang/lib/CodeGen/CGOpenMPRuntime.h
+++ b/clang/lib/CodeGen/CGOpenMPRuntime.h
@@ -1654,65 +1654,16 @@ class CGOpenMPRuntime {
/// Struct that keeps all the relevant information that should be kept
/// throughout a 'target data' region.
- class TargetDataInfo {
- /// Set to true if device pointer information have to be obtained.
- bool RequiresDevicePointerInfo = false;
- /// Set to true if Clang emits separate runtime calls for the beginning and
- /// end of the region. These calls might have separate map type arrays.
- bool SeparateBeginEndCalls = false;
-
+ class TargetDataInfo : public llvm::OpenMPIRBuilder::TargetDataInfo {
public:
- /// The array of base pointer passed to the runtime library.
- llvm::Value *BasePointersArray = nullptr;
- /// The array of section pointers passed to the runtime library.
- llvm::Value *PointersArray = nullptr;
- /// The array of sizes passed to the runtime library.
- llvm::Value *SizesArray = nullptr;
- /// The array of map types passed to the runtime library for the beginning
- /// of the region or for the entire region if there are no separate map
- /// types for the region end.
- llvm::Value *MapTypesArray = nullptr;
- /// The array of map types passed to the runtime library for the end of the
- /// region, or nullptr if there are no separate map types for the region
- /// end.
- llvm::Value *MapTypesArrayEnd = nullptr;
- /// The array of user-defined mappers passed to the runtime library.
- llvm::Value *MappersArray = nullptr;
- /// The array of original declaration names of mapped pointers sent to the
- /// runtime library for debugging
- llvm::Value *MapNamesArray = nullptr;
- /// Indicate whether any user-defined mapper exists.
- bool HasMapper = false;
- /// The total number of pointers passed to the runtime library.
- unsigned NumberOfPtrs = 0u;
+ explicit TargetDataInfo() : llvm::OpenMPIRBuilder::TargetDataInfo() {}
+ explicit TargetDataInfo(bool RequiresDevicePointerInfo,
+ bool SeparateBeginEndCalls)
+ : llvm::OpenMPIRBuilder::TargetDataInfo(RequiresDevicePointerInfo,
+ SeparateBeginEndCalls) {}
/// Map between the a declaration of a capture and the corresponding base
/// pointer address where the runtime returns the device pointers.
llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;
-
- explicit TargetDataInfo() {}
- explicit TargetDataInfo(bool RequiresDevicePointerInfo,
- bool SeparateBeginEndCalls)
- : RequiresDevicePointerInfo(RequiresDevicePointerInfo),
- SeparateBeginEndCalls(SeparateBeginEndCalls) {}
- /// Clear information about the data arrays.
- void clearArrayInfo() {
- BasePointersArray = nullptr;
- PointersArray = nullptr;
- SizesArray = nullptr;
- MapTypesArray = nullptr;
- MapTypesArrayEnd = nullptr;
- MapNamesArray = nullptr;
- MappersArray = nullptr;
- HasMapper = false;
- NumberOfPtrs = 0u;
- }
- /// Return true if the current target data information has valid arrays.
- bool isValid() {
- return BasePointersArray && PointersArray && SizesArray &&
- MapTypesArray && (!HasMapper || MappersArray) && NumberOfPtrs;
- }
- bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
- bool separateBeginEndCalls() { return SeparateBeginEndCalls; }
};
/// Emit the target data mapping code associated with \a D.
@@ -1727,7 +1678,7 @@ class CGOpenMPRuntime {
const OMPExecutableDirective &D,
const Expr *IfCond, const Expr *Device,
const RegionCodeGenTy &CodeGen,
- TargetDataInfo &Info);
+ CGOpenMPRuntime::TargetDataInfo &Info);
/// Emit the data mapping/movement code associated with the directive
/// \a D that should be of the form 'target [{enter|exit} data | update]'.
@@ -2487,7 +2438,7 @@ class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime {
void emitTargetDataCalls(CodeGenFunction &CGF,
const OMPExecutableDirective &D, const Expr *IfCond,
const Expr *Device, const RegionCodeGenTy &CodeGen,
- TargetDataInfo &Info) override;
+ CGOpenMPRuntime::TargetDataInfo &Info) override;
/// Emit the data mapping/movement code associated with the directive
/// \a D that should be of the form 'target [{enter|exit} data | update]'.
diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h b/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
index 0c9f0a9fb2e9d..dcae4392f20ab 100644
--- a/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
+++ b/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
@@ -1002,6 +1002,78 @@ class OpenMPIRBuilder {
struct MapperAllocas &MapperAllocas, int64_t DeviceID,
unsigned NumOperands);
+ /// Container for the arguments used to pass data to the runtime library.
+ struct TargetDataRTArgs {
+ explicit TargetDataRTArgs() {}
+ /// The array of base pointer passed to the runtime library.
+ Value *BasePointersArray = nullptr;
+ /// The array of section pointers passed to the runtime library.
+ Value *PointersArray = nullptr;
+ /// The array of sizes passed to the runtime library.
+ Value *SizesArray = nullptr;
+ /// The array of map types passed to the runtime library for the beginning
+ /// of the region or for the entire region if there are no separate map
+ /// types for the region end.
+ Value *MapTypesArray = nullptr;
+ /// The array of map types passed to the runtime library for the end of the
+ /// region, or nullptr if there are no separate map types for the region
+ /// end.
+ Value *MapTypesArrayEnd = nullptr;
+ /// The array of user-defined mappers passed to the runtime library.
+ Value *MappersArray = nullptr;
+ /// The array of original declaration names of mapped pointers sent to the
+ /// runtime library for debugging
+ Value *MapNamesArray = nullptr;
+ };
+
+ /// Struct that keeps the information that should be kept throughout
+ /// a 'target data' region.
+ class TargetDataInfo {
+ /// Set to true if device pointer information have to be obtained.
+ bool RequiresDevicePointerInfo = false;
+ /// Set to true if Clang emits separate runtime calls for the beginning and
+ /// end of the region. These calls might have separate map type arrays.
+ bool SeparateBeginEndCalls = false;
+
+ public:
+ TargetDataRTArgs RTArgs;
+
+ /// Indicate whether any user-defined mapper exists.
+ bool HasMapper = false;
+ /// The total number of pointers passed to the runtime library.
+ unsigned NumberOfPtrs = 0u;
+
+ explicit TargetDataInfo() {}
+ explicit TargetDataInfo(bool RequiresDevicePointerInfo,
+ bool SeparateBeginEndCalls)
+ : RequiresDevicePointerInfo(RequiresDevicePointerInfo),
+ SeparateBeginEndCalls(SeparateBeginEndCalls) {}
+ /// Clear information about the data arrays.
+ void clearArrayInfo() {
+ RTArgs = TargetDataRTArgs();
+ HasMapper = false;
+ NumberOfPtrs = 0u;
+ }
+ /// Return true if the current target data information has valid arrays.
+ bool isValid() {
+ return RTArgs.BasePointersArray && RTArgs.PointersArray &&
+ RTArgs.SizesArray && RTArgs.MapTypesArray &&
+ (!HasMapper || RTArgs.MappersArray) && NumberOfPtrs;
+ }
+ bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; }
+ bool separateBeginEndCalls() { return SeparateBeginEndCalls; }
+ };
+
+ /// Emit the arguments to be passed to the runtime library based on the
+ /// arrays of base pointers, pointers, sizes, map types, and mappers. If
+ /// ForEndCall, emit map types to be passed for the end of the region instead
+ /// of the beginning.
+ void emitOffloadingArraysArgument(IRBuilderBase &Builder,
+ OpenMPIRBuilder::TargetDataRTArgs &RTArgs,
+ OpenMPIRBuilder::TargetDataInfo &Info,
+ bool EmitDebug = false,
+ bool ForEndCall = false);
+
public:
/// Generator for __kmpc_copyprivate
///
diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
index b0afacbe25cf9..9adcf4525498b 100644
--- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -3990,6 +3990,64 @@ void OpenMPIRBuilder::emitMapperCall(const LocationDescription &Loc,
ArgSizesGEP, MaptypesArg, MapnamesArg, NullPtr});
}
+void OpenMPIRBuilder::emitOffloadingArraysArgument(IRBuilderBase &Builder,
+ TargetDataRTArgs &RTArgs,
+ TargetDataInfo &Info,
+ bool EmitDebug,
+ bool ForEndCall) {
+ assert((!ForEndCall || Info.separateBeginEndCalls()) &&
+ "expected region end call to runtime only when end call is separate");
+ auto VoidPtrTy = Type::getInt8PtrTy(M.getContext());
+ auto VoidPtrPtrTy = VoidPtrTy->getPointerTo(0);
+ auto Int64Ty = Type::getInt64Ty(M.getContext());
+ auto Int64PtrTy = Type::getInt64PtrTy(M.getContext());
+
+ if (!Info.NumberOfPtrs) {
+ RTArgs.BasePointersArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ RTArgs.PointersArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ RTArgs.SizesArray = ConstantPointerNull::get(Int64PtrTy);
+ RTArgs.MapTypesArray = ConstantPointerNull::get(Int64PtrTy);
+ RTArgs.MapNamesArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ RTArgs.MappersArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ return;
+ }
+
+ RTArgs.BasePointersArray = Builder.CreateConstInBoundsGEP2_32(
+ ArrayType::get(VoidPtrTy, Info.NumberOfPtrs),
+ Info.RTArgs.BasePointersArray,
+ /*Idx0=*/0, /*Idx1=*/0);
+ RTArgs.PointersArray = Builder.CreateConstInBoundsGEP2_32(
+ ArrayType::get(VoidPtrTy, Info.NumberOfPtrs), Info.RTArgs.PointersArray,
+ /*Idx0=*/0,
+ /*Idx1=*/0);
+ RTArgs.SizesArray = Builder.CreateConstInBoundsGEP2_32(
+ ArrayType::get(Int64Ty, Info.NumberOfPtrs), Info.RTArgs.SizesArray,
+ /*Idx0=*/0, /*Idx1=*/0);
+ RTArgs.MapTypesArray = Builder.CreateConstInBoundsGEP2_32(
+ ArrayType::get(Int64Ty, Info.NumberOfPtrs),
+ ForEndCall && Info.RTArgs.MapTypesArrayEnd ? Info.RTArgs.MapTypesArrayEnd
+ : Info.RTArgs.MapTypesArray,
+ /*Idx0=*/0,
+ /*Idx1=*/0);
+
+ // Only emit the mapper information arrays if debug information is
+ // requested.
+ if (!EmitDebug)
+ RTArgs.MapNamesArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ else
+ RTArgs.MapNamesArray = Builder.CreateConstInBoundsGEP2_32(
+ ArrayType::get(VoidPtrTy, Info.NumberOfPtrs), Info.RTArgs.MapNamesArray,
+ /*Idx0=*/0,
+ /*Idx1=*/0);
+ // If there is no user-defined mapper, set the mapper array to nullptr to
+ // avoid an unnecessary data privatization
+ if (!Info.HasMapper)
+ RTArgs.MappersArray = ConstantPointerNull::get(VoidPtrPtrTy);
+ else
+ RTArgs.MappersArray =
+ Builder.CreatePointerCast(Info.RTArgs.MappersArray, VoidPtrPtrTy);
+}
+
bool OpenMPIRBuilder::checkAndEmitFlushAfterAtomic(
const LocationDescription &Loc, llvm::AtomicOrdering AO, AtomicKind AK) {
assert(!(AO == AtomicOrdering::NotAtomic ||
diff --git a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
index 9bfe98a8938cf..bcf885d45ca55 100644
--- a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
+++ b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
@@ -5312,4 +5312,55 @@ TEST_F(OpenMPIRBuilderTest, CreateTaskgroupWithTasks) {
verifyDFSOrder(F, RefOrder);
}
+TEST_F(OpenMPIRBuilderTest, EmitOffloadingArraysArguments) {
+ OpenMPIRBuilder OMPBuilder(*M);
+ OMPBuilder.initialize();
+
+ IRBuilder<> Builder(BB);
+
+ OpenMPIRBuilder::TargetDataRTArgs RTArgs;
+ OpenMPIRBuilder::TargetDataInfo Info(true, false);
+
+ auto VoidPtrTy = Type::getInt8PtrTy(Builder.getContext());
+ auto VoidPtrPtrTy = VoidPtrTy->getPointerTo(0);
+ auto Int64Ty = Type::getInt64Ty(Builder.getContext());
+ auto Int64PtrTy = Type::getInt64PtrTy(Builder.getContext());
+ auto Array4VoidPtrTy = ArrayType::get(VoidPtrTy, 4);
+ auto Array4Int64PtrTy = ArrayType::get(Int64Ty, 4);
+
+ Info.RTArgs.BasePointersArray =
+ ConstantPointerNull::get(Array4VoidPtrTy->getPointerTo(0));
+ Info.RTArgs.PointersArray =
+ ConstantPointerNull::get(Array4VoidPtrTy->getPointerTo());
+ Info.RTArgs.SizesArray =
+ ConstantPointerNull::get(Array4Int64PtrTy->getPointerTo());
+ Info.RTArgs.MapTypesArray =
+ ConstantPointerNull::get(Array4Int64PtrTy->getPointerTo());
+ Info.RTArgs.MapNamesArray =
+ ConstantPointerNull::get(Array4VoidPtrTy->getPointerTo());
+ Info.RTArgs.MappersArray =
+ ConstantPointerNull::get(Array4VoidPtrTy->getPointerTo());
+ Info.NumberOfPtrs = 4;
+
+ OMPBuilder.emitOffloadingArraysArgument(Builder, RTArgs, Info, false, false);
+
+ EXPECT_NE(RTArgs.BasePointersArray, nullptr);
+ EXPECT_NE(RTArgs.PointersArray, nullptr);
+ EXPECT_NE(RTArgs.SizesArray, nullptr);
+ EXPECT_NE(RTArgs.MapTypesArray, nullptr);
+ EXPECT_NE(RTArgs.MappersArray, nullptr);
+ EXPECT_NE(RTArgs.MapNamesArray, nullptr);
+ EXPECT_EQ(RTArgs.MapTypesArrayEnd, nullptr);
+
+ EXPECT_EQ(RTArgs.BasePointersArray->getType(), VoidPtrPtrTy);
+ RTArgs.BasePointersArray->getType()->dump();
+ VoidPtrTy->dump();
+ EXPECT_EQ(RTArgs.PointersArray->getType(), VoidPtrPtrTy);
+ EXPECT_EQ(RTArgs.SizesArray->getType(), Int64PtrTy);
+ RTArgs.SizesArray->getType()->dump();
+ Int64PtrTy->dump();
+ EXPECT_EQ(RTArgs.MapTypesArray->getType(), Int64PtrTy);
+ EXPECT_EQ(RTArgs.MappersArray->getType(), VoidPtrPtrTy);
+ EXPECT_EQ(RTArgs.MapNamesArray->getType(), VoidPtrPtrTy);
+}
} // namespace
More information about the cfe-commits
mailing list