Skip to content

Commit 4627cef

Browse files
jsjodinjsjodin
committed
[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
1 parent 14e2592 commit 4627cef

File tree

5 files changed

+258
-200
lines changed

5 files changed

+258
-200
lines changed

‎clang/lib/CodeGen/CGOpenMPRuntime.cpp

Lines changed: 69 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -9442,7 +9442,7 @@ static void emitNonContiguousDescriptor(
94429442
DimsAddr, CGM.Int8PtrTy, CGM.Int8Ty);
94439443
llvm::Value *P = CGF.Builder.CreateConstInBoundsGEP2_32(
94449444
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9445-
Info.PointersArray, 0, I);
9445+
Info.RTArgs.PointersArray, 0, I);
94469446
Address PAddr(P, CGM.VoidPtrTy, CGF.getPointerAlign());
94479447
CGF.Builder.CreateStore(DAddr.getPointer(), PAddr);
94489448
++L;
@@ -9520,13 +9520,13 @@ static void emitOffloadingArrays(
95209520
Ctx.VoidPtrTy, PointerNumAP, nullptr, ArrayType::Normal,
95219521
/*IndexTypeQuals=*/0);
95229522

9523-
Info.BasePointersArray =
9523+
Info.RTArgs.BasePointersArray =
95249524
CGF.CreateMemTemp(PointerArrayType, ".offload_baseptrs").getPointer();
9525-
Info.PointersArray =
9525+
Info.RTArgs.PointersArray =
95269526
CGF.CreateMemTemp(PointerArrayType, ".offload_ptrs").getPointer();
95279527
Address MappersArray =
95289528
CGF.CreateMemTemp(PointerArrayType, ".offload_mappers");
9529-
Info.MappersArray = MappersArray.getPointer();
9529+
Info.RTArgs.MappersArray = MappersArray.getPointer();
95309530

95319531
// If we don't have any VLA types or other types that require runtime
95329532
// evaluation, we can use a constant array for the map sizes, otherwise we
@@ -9555,7 +9555,7 @@ static void emitOffloadingArrays(
95559555
QualType SizeArrayType = Ctx.getConstantArrayType(
95569556
Int64Ty, PointerNumAP, nullptr, ArrayType::Normal,
95579557
/*IndexTypeQuals=*/0);
9558-
Info.SizesArray =
9558+
Info.RTArgs.SizesArray =
95599559
CGF.CreateMemTemp(SizeArrayType, ".offload_sizes").getPointer();
95609560
} else {
95619561
auto *SizesArrayInit = llvm::ConstantArray::get(
@@ -9579,9 +9579,9 @@ static void emitOffloadingArrays(
95799579
CGM.getNaturalTypeAlignment(Ctx.getIntTypeForBitwidth(
95809580
/*DestWidth=*/64, /*Signed=*/false))),
95819581
CGF.getTypeSize(SizeArrayType));
9582-
Info.SizesArray = Buffer.getPointer();
9582+
Info.RTArgs.SizesArray = Buffer.getPointer();
95839583
} else {
9584-
Info.SizesArray = SizesArrayGbl;
9584+
Info.RTArgs.SizesArray = SizesArrayGbl;
95859585
}
95869586
}
95879587

@@ -9593,12 +9593,12 @@ static void emitOffloadingArrays(
95939593
CGM.getOpenMPRuntime().getName({"offload_maptypes"});
95949594
auto *MapTypesArrayGbl =
95959595
OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
9596-
Info.MapTypesArray = MapTypesArrayGbl;
9596+
Info.RTArgs.MapTypesArray = MapTypesArrayGbl;
95979597

95989598
// The information types are only built if there is debug information
95999599
// requested.
96009600
if (CGM.getCodeGenOpts().getDebugInfo() == codegenoptions::NoDebugInfo) {
9601-
Info.MapNamesArray = llvm::Constant::getNullValue(
9601+
Info.RTArgs.MapNamesArray = llvm::Constant::getNullValue(
96029602
llvm::Type::getInt8Ty(CGF.Builder.getContext())->getPointerTo());
96039603
} else {
96049604
auto fillInfoMap = [&](MappableExprsHandler::MappingExprInfo &MapExpr) {
@@ -9610,7 +9610,7 @@ static void emitOffloadingArrays(
96109610
CGM.getOpenMPRuntime().getName({"offload_mapnames"});
96119611
auto *MapNamesArrayGbl =
96129612
OMPBuilder.createOffloadMapnames(InfoMap, MapnamesName);
9613-
Info.MapNamesArray = MapNamesArrayGbl;
9613+
Info.RTArgs.MapNamesArray = MapNamesArrayGbl;
96149614
}
96159615

96169616
// If there's a present map type modifier, it must not be applied to the end
@@ -9626,15 +9626,15 @@ static void emitOffloadingArrays(
96269626
if (EndMapTypesDiffer) {
96279627
MapTypesArrayGbl =
96289628
OMPBuilder.createOffloadMaptypes(Mapping, MaptypesName);
9629-
Info.MapTypesArrayEnd = MapTypesArrayGbl;
9629+
Info.RTArgs.MapTypesArrayEnd = MapTypesArrayGbl;
96309630
}
96319631
}
96329632

96339633
for (unsigned I = 0; I < Info.NumberOfPtrs; ++I) {
96349634
llvm::Value *BPVal = *CombinedInfo.BasePointers[I];
96359635
llvm::Value *BP = CGF.Builder.CreateConstInBoundsGEP2_32(
96369636
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9637-
Info.BasePointersArray, 0, I);
9637+
Info.RTArgs.BasePointersArray, 0, I);
96389638
BP = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
96399639
BP, BPVal->getType()->getPointerTo(/*AddrSpace=*/0));
96409640
Address BPAddr(BP, BPVal->getType(),
@@ -9649,7 +9649,7 @@ static void emitOffloadingArrays(
96499649
llvm::Value *PVal = CombinedInfo.Pointers[I];
96509650
llvm::Value *P = CGF.Builder.CreateConstInBoundsGEP2_32(
96519651
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9652-
Info.PointersArray, 0, I);
9652+
Info.RTArgs.PointersArray, 0, I);
96539653
P = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
96549654
P, PVal->getType()->getPointerTo(/*AddrSpace=*/0));
96559655
Address PAddr(P, PVal->getType(), Ctx.getTypeAlignInChars(Ctx.VoidPtrTy));
@@ -9658,7 +9658,7 @@ static void emitOffloadingArrays(
96589658
if (RuntimeSizes.test(I)) {
96599659
llvm::Value *S = CGF.Builder.CreateConstInBoundsGEP2_32(
96609660
llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs),
9661-
Info.SizesArray,
9661+
Info.RTArgs.SizesArray,
96629662
/*Idx0=*/0,
96639663
/*Idx1=*/I);
96649664
Address SAddr(S, CGM.Int64Ty, Ctx.getTypeAlignInChars(Int64Ty));
@@ -9688,76 +9688,6 @@ static void emitOffloadingArrays(
96889688
emitNonContiguousDescriptor(CGF, CombinedInfo, Info);
96899689
}
96909690

9691-
namespace {
9692-
/// Additional arguments for emitOffloadingArraysArgument function.
9693-
struct ArgumentsOptions {
9694-
bool ForEndCall = false;
9695-
ArgumentsOptions() = default;
9696-
ArgumentsOptions(bool ForEndCall) : ForEndCall(ForEndCall) {}
9697-
};
9698-
} // namespace
9699-
9700-
/// Emit the arguments to be passed to the runtime library based on the
9701-
/// arrays of base pointers, pointers, sizes, map types, and mappers. If
9702-
/// ForEndCall, emit map types to be passed for the end of the region instead of
9703-
/// the beginning.
9704-
static void emitOffloadingArraysArgument(
9705-
CodeGenFunction &CGF, llvm::Value *&BasePointersArrayArg,
9706-
llvm::Value *&PointersArrayArg, llvm::Value *&SizesArrayArg,
9707-
llvm::Value *&MapTypesArrayArg, llvm::Value *&MapNamesArrayArg,
9708-
llvm::Value *&MappersArrayArg, CGOpenMPRuntime::TargetDataInfo &Info,
9709-
const ArgumentsOptions &Options = ArgumentsOptions()) {
9710-
assert((!Options.ForEndCall || Info.separateBeginEndCalls()) &&
9711-
"expected region end call to runtime only when end call is separate");
9712-
CodeGenModule &CGM = CGF.CGM;
9713-
if (Info.NumberOfPtrs) {
9714-
BasePointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
9715-
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9716-
Info.BasePointersArray,
9717-
/*Idx0=*/0, /*Idx1=*/0);
9718-
PointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
9719-
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9720-
Info.PointersArray,
9721-
/*Idx0=*/0,
9722-
/*Idx1=*/0);
9723-
SizesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
9724-
llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs), Info.SizesArray,
9725-
/*Idx0=*/0, /*Idx1=*/0);
9726-
MapTypesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
9727-
llvm::ArrayType::get(CGM.Int64Ty, Info.NumberOfPtrs),
9728-
Options.ForEndCall && Info.MapTypesArrayEnd ? Info.MapTypesArrayEnd
9729-
: Info.MapTypesArray,
9730-
/*Idx0=*/0,
9731-
/*Idx1=*/0);
9732-
9733-
// Only emit the mapper information arrays if debug information is
9734-
// requested.
9735-
if (CGF.CGM.getCodeGenOpts().getDebugInfo() == codegenoptions::NoDebugInfo)
9736-
MapNamesArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9737-
else
9738-
MapNamesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
9739-
llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),
9740-
Info.MapNamesArray,
9741-
/*Idx0=*/0,
9742-
/*Idx1=*/0);
9743-
// If there is no user-defined mapper, set the mapper array to nullptr to
9744-
// avoid an unnecessary data privatization
9745-
if (!Info.HasMapper)
9746-
MappersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9747-
else
9748-
MappersArrayArg =
9749-
CGF.Builder.CreatePointerCast(Info.MappersArray, CGM.VoidPtrPtrTy);
9750-
} else {
9751-
BasePointersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9752-
PointersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9753-
SizesArrayArg = llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());
9754-
MapTypesArrayArg =
9755-
llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());
9756-
MapNamesArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9757-
MappersArrayArg = llvm::ConstantPointerNull::get(CGM.VoidPtrPtrTy);
9758-
}
9759-
}
9760-
97619691
/// Check for inner distribute directive.
97629692
static const OMPExecutableDirective *
97639693
getNestedDistributeDirective(ASTContext &Ctx, const OMPExecutableDirective &D) {
@@ -10479,25 +10409,26 @@ void CGOpenMPRuntime::emitTargetCall(
1047910409
// weren't referenced within the construct.
1048010410
MEHandler.generateAllInfo(CombinedInfo, MappedVarSet);
1048110411

10482-
TargetDataInfo Info;
10412+
CGOpenMPRuntime::TargetDataInfo Info;
1048310413
// Fill up the arrays and create the arguments.
1048410414
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder);
10485-
emitOffloadingArraysArgument(
10486-
CGF, Info.BasePointersArray, Info.PointersArray, Info.SizesArray,
10487-
Info.MapTypesArray, Info.MapNamesArray, Info.MappersArray, Info,
10488-
{/*ForEndCall=*/false});
10415+
bool EmitDebug =
10416+
CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
10417+
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
10418+
EmitDebug,
10419+
/*ForEndCall=*/false);
1048910420

1049010421
InputInfo.NumberOfTargetItems = Info.NumberOfPtrs;
10491-
InputInfo.BasePointersArray =
10492-
Address(Info.BasePointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
10493-
InputInfo.PointersArray =
10494-
Address(Info.PointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
10422+
InputInfo.BasePointersArray = Address(Info.RTArgs.BasePointersArray,
10423+
CGF.VoidPtrTy, CGM.getPointerAlign());
10424+
InputInfo.PointersArray = Address(Info.RTArgs.PointersArray, CGF.VoidPtrTy,
10425+
CGM.getPointerAlign());
1049510426
InputInfo.SizesArray =
10496-
Address(Info.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
10427+
Address(Info.RTArgs.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
1049710428
InputInfo.MappersArray =
10498-
Address(Info.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
10499-
MapTypesArray = Info.MapTypesArray;
10500-
MapNamesArray = Info.MapNamesArray;
10429+
Address(Info.RTArgs.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
10430+
MapTypesArray = Info.RTArgs.MapTypesArray;
10431+
MapNamesArray = Info.RTArgs.MapNamesArray;
1050110432
if (RequiresOuterTask)
1050210433
CGF.EmitOMPTargetTaskBasedDirective(D, ThenGen, InputInfo);
1050310434
else
@@ -11063,7 +10994,8 @@ void CGOpenMPRuntime::emitNumTeamsClause(CodeGenFunction &CGF,
1106310994

1106410995
void CGOpenMPRuntime::emitTargetDataCalls(
1106510996
CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
11066-
const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
10997+
const Expr *Device, const RegionCodeGenTy &CodeGen,
10998+
CGOpenMPRuntime::TargetDataInfo &Info) {
1106710999
if (!CGF.HaveInsertPoint())
1106811000
return;
1106911001

@@ -11087,15 +11019,11 @@ void CGOpenMPRuntime::emitTargetDataCalls(
1108711019
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder,
1108811020
/*IsNonContiguous=*/true);
1108911021

11090-
llvm::Value *BasePointersArrayArg = nullptr;
11091-
llvm::Value *PointersArrayArg = nullptr;
11092-
llvm::Value *SizesArrayArg = nullptr;
11093-
llvm::Value *MapTypesArrayArg = nullptr;
11094-
llvm::Value *MapNamesArrayArg = nullptr;
11095-
llvm::Value *MappersArrayArg = nullptr;
11096-
emitOffloadingArraysArgument(CGF, BasePointersArrayArg, PointersArrayArg,
11097-
SizesArrayArg, MapTypesArrayArg,
11098-
MapNamesArrayArg, MappersArrayArg, Info);
11022+
llvm::OpenMPIRBuilder::TargetDataRTArgs RTArgs;
11023+
bool EmitDebug =
11024+
CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
11025+
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, RTArgs, Info,
11026+
EmitDebug);
1109911027

1110011028
// Emit device ID if any.
1110111029
llvm::Value *DeviceID = nullptr;
@@ -11115,12 +11043,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
1111511043
llvm::Value *OffloadingArgs[] = {RTLoc,
1111611044
DeviceID,
1111711045
PointerNum,
11118-
BasePointersArrayArg,
11119-
PointersArrayArg,
11120-
SizesArrayArg,
11121-
MapTypesArrayArg,
11122-
MapNamesArrayArg,
11123-
MappersArrayArg};
11046+
RTArgs.BasePointersArray,
11047+
RTArgs.PointersArray,
11048+
RTArgs.SizesArray,
11049+
RTArgs.MapTypesArray,
11050+
RTArgs.MapNamesArray,
11051+
RTArgs.MappersArray};
1112411052
CGF.EmitRuntimeCall(
1112511053
OMPBuilder.getOrCreateRuntimeFunction(
1112611054
CGM.getModule(), OMPRTL___tgt_target_data_begin_mapper),
@@ -11137,16 +11065,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
1113711065
PrePostActionTy &) {
1113811066
assert(Info.isValid() && "Invalid data environment closing arguments.");
1113911067

11140-
llvm::Value *BasePointersArrayArg = nullptr;
11141-
llvm::Value *PointersArrayArg = nullptr;
11142-
llvm::Value *SizesArrayArg = nullptr;
11143-
llvm::Value *MapTypesArrayArg = nullptr;
11144-
llvm::Value *MapNamesArrayArg = nullptr;
11145-
llvm::Value *MappersArrayArg = nullptr;
11146-
emitOffloadingArraysArgument(CGF, BasePointersArrayArg, PointersArrayArg,
11147-
SizesArrayArg, MapTypesArrayArg,
11148-
MapNamesArrayArg, MappersArrayArg, Info,
11149-
{/*ForEndCall=*/true});
11068+
llvm::OpenMPIRBuilder::TargetDataRTArgs RTArgs;
11069+
bool EmitDebug =
11070+
CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
11071+
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, RTArgs, Info,
11072+
EmitDebug,
11073+
/*ForEndCall=*/true);
1115011074

1115111075
// Emit device ID if any.
1115211076
llvm::Value *DeviceID = nullptr;
@@ -11166,12 +11090,12 @@ void CGOpenMPRuntime::emitTargetDataCalls(
1116611090
llvm::Value *OffloadingArgs[] = {RTLoc,
1116711091
DeviceID,
1116811092
PointerNum,
11169-
BasePointersArrayArg,
11170-
PointersArrayArg,
11171-
SizesArrayArg,
11172-
MapTypesArrayArg,
11173-
MapNamesArrayArg,
11174-
MappersArrayArg};
11093+
RTArgs.BasePointersArray,
11094+
RTArgs.PointersArray,
11095+
RTArgs.SizesArray,
11096+
RTArgs.MapTypesArray,
11097+
RTArgs.MapNamesArray,
11098+
RTArgs.MappersArray};
1117511099
CGF.EmitRuntimeCall(
1117611100
OMPBuilder.getOrCreateRuntimeFunction(
1117711101
CGM.getModule(), OMPRTL___tgt_target_data_end_mapper),
@@ -11360,27 +11284,28 @@ void CGOpenMPRuntime::emitTargetDataStandAloneCall(
1136011284
MappableExprsHandler MEHandler(D, CGF);
1136111285
MEHandler.generateAllInfo(CombinedInfo);
1136211286

11363-
TargetDataInfo Info;
11287+
CGOpenMPRuntime::TargetDataInfo Info;
1136411288
// Fill up the arrays and create the arguments.
1136511289
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder,
1136611290
/*IsNonContiguous=*/true);
1136711291
bool RequiresOuterTask = D.hasClausesOfKind<OMPDependClause>() ||
1136811292
D.hasClausesOfKind<OMPNowaitClause>();
11369-
emitOffloadingArraysArgument(
11370-
CGF, Info.BasePointersArray, Info.PointersArray, Info.SizesArray,
11371-
Info.MapTypesArray, Info.MapNamesArray, Info.MappersArray, Info,
11372-
{/*ForEndCall=*/false});
11293+
bool EmitDebug =
11294+
CGF.CGM.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo;
11295+
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
11296+
EmitDebug,
11297+
/*ForEndCall=*/false);
1137311298
InputInfo.NumberOfTargetItems = Info.NumberOfPtrs;
11374-
InputInfo.BasePointersArray =
11375-
Address(Info.BasePointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
11376-
InputInfo.PointersArray =
11377-
Address(Info.PointersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
11299+
InputInfo.BasePointersArray = Address(Info.RTArgs.BasePointersArray,
11300+
CGF.VoidPtrTy, CGM.getPointerAlign());
11301+
InputInfo.PointersArray = Address(Info.RTArgs.PointersArray, CGF.VoidPtrTy,
11302+
CGM.getPointerAlign());
1137811303
InputInfo.SizesArray =
11379-
Address(Info.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
11304+
Address(Info.RTArgs.SizesArray, CGF.Int64Ty, CGM.getPointerAlign());
1138011305
InputInfo.MappersArray =
11381-
Address(Info.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
11382-
MapTypesArray = Info.MapTypesArray;
11383-
MapNamesArray = Info.MapNamesArray;
11306+
Address(Info.RTArgs.MappersArray, CGF.VoidPtrTy, CGM.getPointerAlign());
11307+
MapTypesArray = Info.RTArgs.MapTypesArray;
11308+
MapNamesArray = Info.RTArgs.MapNamesArray;
1138411309
if (RequiresOuterTask)
1138511310
CGF.EmitOMPTargetTaskBasedDirective(D, ThenGen, InputInfo);
1138611311
else
@@ -13075,7 +13000,8 @@ void CGOpenMPSIMDRuntime::emitNumTeamsClause(CodeGenFunction &CGF,
1307513000

1307613001
void CGOpenMPSIMDRuntime::emitTargetDataCalls(
1307713002
CodeGenFunction &CGF, const OMPExecutableDirective &D, const Expr *IfCond,
13078-
const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) {
13003+
const Expr *Device, const RegionCodeGenTy &CodeGen,
13004+
CGOpenMPRuntime::TargetDataInfo &Info) {
1307913005
llvm_unreachable("Not supported in SIMD-only mode");
1308013006
}
1308113007

0 commit comments

Comments
 (0)