Skip to content

Commit 0f80c45

Browse files
tblahtblah
committed
[OMPIRBuilder] always leave PARALLEL via the same barrier
A barrier will pause execution until all threads reach it. If some go to a different barrier then we deadlock. This manifests in that the finalization callback must only be run once. Fix by ensuring we always go through the same finalization block whether the thread in cancelled or not and no matter which cancellation point causes the cancellation. The old callback only affected PARALLEL, so it has been moved into the code generating PARALLEL. For this reason, we don't need similar changes for other cancellable constructs. We need to create the barrier on the shared exit from the outlined function instead of only on the cancelled branch to make sure that threads exiting normally (without cancellation) meet the same barriers as those which were cancelled. For example, previously we might have generated code like ``` ... %ret = call i32 @__kmpc_cancel(...) %cond = icmp eq i32 %ret, 0 br i1 %cond, label %continue, label %cancel continue: // do the rest of the callback, eventually branching to %fini br label %fini cancel: // Populated by the callback: // unsafe: if any thread makes it to the end without being cancelled // it won't reach this barrier and then the program will deadlock %unused = call i32 @__kmpc_cancel_barrier(...) br label %fini fini: // run destructors etc ret ``` In the new version the barrier is moved into fini. I generate it *after* the destructors because the standard describes the barrier as occurring after the end of the parallel region. ``` ... %ret = call i32 @__kmpc_cancel(...) %cond = icmp eq i32 %ret, 0 br i1 %cond, label %continue, label %cancel continue: // do the rest of the callback, eventually branching to %fini br label %fini cancel: br label %fini fini: // run destructors etc // safe so long as every exit from the function happens via this block: %unused = call i32 @__kmpc_cancel_barrier(...) ret ``` To achieve this, the barrier is now generated alongside the finalization code instead of in the callback. This is the reason for the changes to the unit test. I'm unsure if I should keep the incorrect barrier generation callback only on the cancellation branch in clang with the OMPIRBuilder backend because that would match clang's ordinary codegen. Right now I have opted to remove it entirely because it is a deadlock waiting to happen.
1 parent 7152d4e commit 0f80c45

File tree

8 files changed

+124
-117
lines changed

8 files changed

+124
-117
lines changed

‎clang/test/OpenMP/cancel_codegen.cpp‎

Lines changed: 20 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -811,16 +811,16 @@ for (int i = 0; i < argc; ++i) {
811811
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_BODY_CASE23_SECTION_AFTER:%.*]]
812812
// CHECK3: omp_section_loop.body.case23.section.after:
813813
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_BODY16_SECTIONS_AFTER]]
814-
// CHECK3: omp_section_loop.body.case25:
814+
// CHECK3: omp_section_loop.body.case26:
815815
// CHECK3-NEXT: [[OMP_GLOBAL_THREAD_NUM27:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB1]])
816816
// CHECK3-NEXT: [[TMP18:%.*]] = call i32 @__kmpc_cancel(ptr @[[GLOB1]], i32 [[OMP_GLOBAL_THREAD_NUM27]], i32 3)
817817
// CHECK3-NEXT: [[TMP19:%.*]] = icmp eq i32 [[TMP18]], 0
818818
// CHECK3-NEXT: br i1 [[TMP19]], label [[OMP_SECTION_LOOP_BODY_CASE25_SPLIT:%.*]], label [[OMP_SECTION_LOOP_BODY_CASE25_CNCL:%.*]]
819-
// CHECK3: omp_section_loop.body.case25.split:
819+
// CHECK3: omp_section_loop.body.case26.split:
820820
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_BODY_CASE25_SECTION_AFTER26:%.*]]
821-
// CHECK3: omp_section_loop.body.case25.section.after26:
821+
// CHECK3: omp_section_loop.body.case26.section.after27:
822822
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_BODY_CASE25_SECTION_AFTER:%.*]]
823-
// CHECK3: omp_section_loop.body.case25.section.after:
823+
// CHECK3: omp_section_loop.body.case26.section.after:
824824
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_BODY16_SECTIONS_AFTER]]
825825
// CHECK3: omp_section_loop.body16.sections.after:
826826
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_INC17]]
@@ -891,10 +891,12 @@ for (int i = 0; i < argc; ++i) {
891891
// CHECK3: .cancel.exit:
892892
// CHECK3-NEXT: br label [[CANCEL_EXIT:%.*]]
893893
// CHECK3: omp_section_loop.body.case.cncl:
894-
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_EXIT]]
895-
// CHECK3: omp_section_loop.body.case23.cncl:
894+
// CHECK3-NEXT: br label [[FINI10:.*]]
895+
// CHECK3: .fini25:
896896
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_EXIT18]]
897-
// CHECK3: omp_section_loop.body.case25.cncl:
897+
// CHECK3: omp_section_loop.body.case26.cncl:
898+
// CHECK3-NEXT: br label [[FINI29:.*]]
899+
// CHECK3: .fini29:
898900
// CHECK3-NEXT: br label [[OMP_SECTION_LOOP_EXIT18]]
899901
// CHECK3: .cancel.continue:
900902
// CHECK3-NEXT: br label [[OMP_IF_END:%.*]]
@@ -967,8 +969,10 @@ for (int i = 0; i < argc; ++i) {
967969
// CHECK3-NEXT: [[TMP8:%.*]] = call i32 @__kmpc_cancel_barrier(ptr @[[GLOB3:[0-9]+]], i32 [[OMP_GLOBAL_THREAD_NUM4]])
968970
// CHECK3-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0
969971
// CHECK3-NEXT: br i1 [[TMP9]], label [[DOTCONT:%.*]], label [[DOTCNCL5:%.*]]
970-
// CHECK3: .cncl5:
971-
// CHECK3-NEXT: br label [[OMP_PAR_OUTLINED_EXIT_EXITSTUB:%.*]]
972+
// CHECK3: .cncl4:
973+
// CHECK3-NEXT: br label [[FINI:%.*]]
974+
// CHECK3: .fini
975+
// CHECK3-NEXT: br label %[[EXIT_STUB:omp.par.exit.exitStub]]
972976
// CHECK3: .cont:
973977
// CHECK3-NEXT: [[TMP10:%.*]] = load i32, ptr [[LOADGEP_ARGC_ADDR]], align 4
974978
// CHECK3-NEXT: [[TMP11:%.*]] = load ptr, ptr [[LOADGEP_ARGV_ADDR]], align 8
@@ -984,16 +988,14 @@ for (int i = 0; i < argc; ++i) {
984988
// CHECK3: omp.par.region.parallel.after:
985989
// CHECK3-NEXT: br label [[OMP_PAR_PRE_FINALIZE:%.*]]
986990
// CHECK3: omp.par.pre_finalize:
987-
// CHECK3-NEXT: br label [[OMP_PAR_OUTLINED_EXIT_EXITSTUB]]
991+
// CHECK3-NEXT: br label [[FINI]]
988992
// CHECK3: 14:
989993
// CHECK3-NEXT: [[OMP_GLOBAL_THREAD_NUM1:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB1]])
990994
// CHECK3-NEXT: [[TMP15:%.*]] = call i32 @__kmpc_cancel(ptr @[[GLOB1]], i32 [[OMP_GLOBAL_THREAD_NUM1]], i32 1)
991995
// CHECK3-NEXT: [[TMP16:%.*]] = icmp eq i32 [[TMP15]], 0
992996
// CHECK3-NEXT: br i1 [[TMP16]], label [[DOTSPLIT:%.*]], label [[DOTCNCL:%.*]]
993997
// CHECK3: .cncl:
994-
// CHECK3-NEXT: [[OMP_GLOBAL_THREAD_NUM2:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB1]])
995-
// CHECK3-NEXT: [[TMP17:%.*]] = call i32 @__kmpc_cancel_barrier(ptr @[[GLOB2]], i32 [[OMP_GLOBAL_THREAD_NUM2]])
996-
// CHECK3-NEXT: br label [[OMP_PAR_OUTLINED_EXIT_EXITSTUB]]
998+
// CHECK3-NEXT: br label [[FINI]]
997999
// CHECK3: .split:
9981000
// CHECK3-NEXT: br label [[TMP4]]
9991001
// CHECK3: omp.par.exit.exitStub:
@@ -1089,7 +1091,7 @@ for (int i = 0; i < argc; ++i) {
10891091
// CHECK3: .omp.sections.case.split:
10901092
// CHECK3-NEXT: br label [[DOTOMP_SECTIONS_EXIT]]
10911093
// CHECK3: .omp.sections.case.cncl:
1092-
// CHECK3-NEXT: br label [[CANCEL_CONT:%.*]]
1094+
// CHECK3-NEXT: br label [[FINI:%.*]]
10931095
// CHECK3: .omp.sections.exit:
10941096
// CHECK3-NEXT: br label [[OMP_INNER_FOR_INC:%.*]]
10951097
// CHECK3: omp.inner.for.inc:
@@ -1100,7 +1102,7 @@ for (int i = 0; i < argc; ++i) {
11001102
// CHECK3: omp.inner.for.end:
11011103
// CHECK3-NEXT: [[OMP_GLOBAL_THREAD_NUM3:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB19:[0-9]+]])
11021104
// CHECK3-NEXT: call void @__kmpc_for_static_fini(ptr @[[GLOB15]], i32 [[OMP_GLOBAL_THREAD_NUM3]])
1103-
// CHECK3-NEXT: br label [[CANCEL_CONT]]
1105+
// CHECK3-NEXT: br label [[CANCEL_CONT:.*]]
11041106
// CHECK3: cancel.cont:
11051107
// CHECK3-NEXT: ret void
11061108
// CHECK3: cancel.exit:
@@ -1153,6 +1155,8 @@ for (int i = 0; i < argc; ++i) {
11531155
// CHECK3: .omp.sections.case.split:
11541156
// CHECK3-NEXT: br label [[DOTOMP_SECTIONS_EXIT]]
11551157
// CHECK3: .omp.sections.case.cncl:
1158+
// CHECK3-NEXT: br label [[DOTFINI:.%*]]
1159+
// CHECK3: .fini:
11561160
// CHECK3-NEXT: br label [[CANCEL_CONT:%.*]]
11571161
// CHECK3: .omp.sections.case2:
11581162
// CHECK3-NEXT: [[OMP_GLOBAL_THREAD_NUM3:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB1]])
@@ -1164,7 +1168,7 @@ for (int i = 0; i < argc; ++i) {
11641168
// CHECK3: .omp.sections.case2.section.after:
11651169
// CHECK3-NEXT: br label [[DOTOMP_SECTIONS_EXIT]]
11661170
// CHECK3: .omp.sections.case2.cncl:
1167-
// CHECK3-NEXT: br label [[OMP_INNER_FOR_END]]
1171+
// CHECK3-NEXT: br label [[FINI:.*]]
11681172
// CHECK3: .omp.sections.exit:
11691173
// CHECK3-NEXT: br label [[OMP_INNER_FOR_INC:%.*]]
11701174
// CHECK3: omp.inner.for.inc:

‎llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -580,6 +580,11 @@ class OpenMPIRBuilder {
580580

581581
/// Flag to indicate if the directive is cancellable.
582582
bool IsCancellable;
583+
584+
/// The basic block to which control should be transferred to
585+
/// implement the FiniCB. Memoized to avoid generating finalization
586+
/// multiple times.
587+
llvm::BasicBlock *FiniBB = nullptr;
583588
};
584589

585590
/// Push a finalization callback on the finalization stack.
@@ -2181,8 +2186,7 @@ class OpenMPIRBuilder {
21812186
///
21822187
/// \return an error, if any were triggered during execution.
21832188
LLVM_ABI Error emitCancelationCheckImpl(Value *CancelFlag,
2184-
omp::Directive CanceledDirective,
2185-
FinalizeCallbackTy ExitCB = {});
2189+
omp::Directive CanceledDirective);
21862190

21872191
/// Generate a target region entry call.
21882192
///

‎llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp‎

Lines changed: 31 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1108,21 +1108,9 @@ OpenMPIRBuilder::createCancel(const LocationDescription &Loc,
11081108
Value *Args[] = {Ident, getOrCreateThreadID(Ident), CancelKind};
11091109
Value *Result = Builder.CreateCall(
11101110
getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_cancel), Args);
1111-
auto ExitCB = [this, CanceledDirective, Loc](InsertPointTy IP) -> Error {
1112-
if (CanceledDirective == OMPD_parallel) {
1113-
IRBuilder<>::InsertPointGuard IPG(Builder);
1114-
Builder.restoreIP(IP);
1115-
return createBarrier(LocationDescription(Builder.saveIP(), Loc.DL),
1116-
omp::Directive::OMPD_unknown,
1117-
/* ForceSimpleCall */ false,
1118-
/* CheckCancelFlag */ false)
1119-
.takeError();
1120-
}
1121-
return Error::success();
1122-
};
11231111

11241112
// The actual cancel logic is shared with others, e.g., cancel_barriers.
1125-
if (Error Err = emitCancelationCheckImpl(Result, CanceledDirective, ExitCB))
1113+
if (Error Err = emitCancelationCheckImpl(Result, CanceledDirective))
11261114
return Err;
11271115

11281116
// Update the insertion point and remove the terminator we introduced.
@@ -1159,21 +1147,9 @@ OpenMPIRBuilder::createCancellationPoint(const LocationDescription &Loc,
11591147
Value *Args[] = {Ident, getOrCreateThreadID(Ident), CancelKind};
11601148
Value *Result = Builder.CreateCall(
11611149
getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_cancellationpoint), Args);
1162-
auto ExitCB = [this, CanceledDirective, Loc](InsertPointTy IP) -> Error {
1163-
if (CanceledDirective == OMPD_parallel) {
1164-
IRBuilder<>::InsertPointGuard IPG(Builder);
1165-
Builder.restoreIP(IP);
1166-
return createBarrier(LocationDescription(Builder.saveIP(), Loc.DL),
1167-
omp::Directive::OMPD_unknown,
1168-
/* ForceSimpleCall */ false,
1169-
/* CheckCancelFlag */ false)
1170-
.takeError();
1171-
}
1172-
return Error::success();
1173-
};
11741150

11751151
// The actual cancel logic is shared with others, e.g., cancel_barriers.
1176-
if (Error Err = emitCancelationCheckImpl(Result, CanceledDirective, ExitCB))
1152+
if (Error Err = emitCancelationCheckImpl(Result, CanceledDirective))
11771153
return Err;
11781154

11791155
// Update the insertion point and remove the terminator we introduced.
@@ -1277,8 +1253,7 @@ OpenMPIRBuilder::InsertPointOrErrorTy OpenMPIRBuilder::emitKernelLaunch(
12771253
}
12781254

12791255
Error OpenMPIRBuilder::emitCancelationCheckImpl(
1280-
Value *CancelFlag, omp::Directive CanceledDirective,
1281-
FinalizeCallbackTy ExitCB) {
1256+
Value *CancelFlag, omp::Directive CanceledDirective) {
12821257
assert(isLastFinalizationInfoCancellable(CanceledDirective) &&
12831258
"Unexpected cancellation!");
12841259

@@ -1305,13 +1280,17 @@ Error OpenMPIRBuilder::emitCancelationCheckImpl(
13051280

13061281
// From the cancellation block we finalize all variables and go to the
13071282
// post finalization block that is known to the FiniCB callback.
1308-
Builder.SetInsertPoint(CancellationBlock);
1309-
if (ExitCB)
1310-
if (Error Err = ExitCB(Builder.saveIP()))
1311-
return Err;
13121283
auto &FI = FinalizationStack.back();
1313-
if (Error Err = FI.FiniCB(Builder.saveIP()))
1314-
return Err;
1284+
if (!FI.FiniBB) {
1285+
llvm::IRBuilderBase::InsertPointGuard Guard(Builder);
1286+
FI.FiniBB = BasicBlock::Create(BB->getContext(), ".fini", BB->getParent());
1287+
Builder.SetInsertPoint(FI.FiniBB);
1288+
// FiniCB adds the branch to the exit stub.
1289+
if (Error Err = FI.FiniCB(Builder.saveIP()))
1290+
return Err;
1291+
}
1292+
Builder.SetInsertPoint(CancellationBlock);
1293+
Builder.CreateBr(FI.FiniBB);
13151294

13161295
// The continuation block is where code generation continues.
13171296
Builder.SetInsertPoint(NonCancellationBlock, NonCancellationBlock->begin());
@@ -1800,8 +1779,18 @@ OpenMPIRBuilder::InsertPointOrErrorTy OpenMPIRBuilder::createParallel(
18001779
Instruction *PRegPreFiniTI = PRegPreFiniBB->getTerminator();
18011780

18021781
InsertPointTy PreFiniIP(PRegPreFiniBB, PRegPreFiniTI->getIterator());
1803-
if (Error Err = FiniCB(PreFiniIP))
1804-
return Err;
1782+
if (!FiniInfo.FiniBB) {
1783+
if (Error Err = FiniCB(PreFiniIP))
1784+
return Err;
1785+
} else {
1786+
llvm::IRBuilderBase::InsertPointGuard Guard{Builder};
1787+
Builder.restoreIP(PreFiniIP);
1788+
Builder.CreateBr(FiniInfo.FiniBB);
1789+
// There's currently a branch to omp.par.exit. Delete it. We will get there
1790+
// via the fini block
1791+
if (llvm::Instruction *Term = Builder.GetInsertBlock()->getTerminator())
1792+
Term->eraseFromParent();
1793+
}
18051794

18061795
// Register the outlined info.
18071796
addOutlineInfo(std::move(OI));
@@ -6556,13 +6545,14 @@ OpenMPIRBuilder::InsertPointOrErrorTy OpenMPIRBuilder::emitCommonDirectiveExit(
65566545
FinalizationInfo Fi = FinalizationStack.pop_back_val();
65576546
assert(Fi.DK == OMPD && "Unexpected Directive for Finalization call!");
65586547

6559-
if (Error Err = Fi.FiniCB(FinIP))
6560-
return Err;
6561-
6562-
BasicBlock *FiniBB = FinIP.getBlock();
6563-
Instruction *FiniBBTI = FiniBB->getTerminator();
6548+
if (!Fi.FiniBB) {
6549+
if (Error Err = Fi.FiniCB(FinIP))
6550+
return Err;
6551+
Fi.FiniBB = FinIP.getBlock();
6552+
}
65646553

65656554
// set Builder IP for call creation
6555+
Instruction *FiniBBTI = Fi.FiniBB->getTerminator();
65666556
Builder.SetInsertPoint(FiniBBTI);
65676557
}
65686558

‎llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp‎

Lines changed: 27 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -428,8 +428,8 @@ TEST_F(OpenMPIRBuilderTest, CreateCancel) {
428428
OMPBuilder.createCancel(Loc, nullptr, OMPD_parallel));
429429
Builder.restoreIP(NewIP);
430430
EXPECT_FALSE(M->global_empty());
431-
EXPECT_EQ(M->size(), 4U);
432-
EXPECT_EQ(F->size(), 4U);
431+
EXPECT_EQ(M->size(), 3U);
432+
EXPECT_EQ(F->size(), 5U);
433433
EXPECT_EQ(BB->size(), 4U);
434434

435435
CallInst *GTID = dyn_cast<CallInst>(&BB->front());
@@ -449,23 +449,16 @@ TEST_F(OpenMPIRBuilderTest, CreateCancel) {
449449
Instruction *CancelBBTI = Cancel->getParent()->getTerminator();
450450
EXPECT_EQ(CancelBBTI->getNumSuccessors(), 2U);
451451
EXPECT_EQ(CancelBBTI->getSuccessor(0), NewIP.getBlock());
452-
EXPECT_EQ(CancelBBTI->getSuccessor(1)->size(), 3U);
453-
CallInst *GTID1 = dyn_cast<CallInst>(&CancelBBTI->getSuccessor(1)->front());
454-
EXPECT_NE(GTID1, nullptr);
455-
EXPECT_EQ(GTID1->arg_size(), 1U);
456-
EXPECT_EQ(GTID1->getCalledFunction()->getName(), "__kmpc_global_thread_num");
457-
EXPECT_FALSE(GTID1->getCalledFunction()->doesNotAccessMemory());
458-
EXPECT_FALSE(GTID1->getCalledFunction()->doesNotFreeMemory());
459-
CallInst *Barrier = dyn_cast<CallInst>(GTID1->getNextNode());
460-
EXPECT_NE(Barrier, nullptr);
461-
EXPECT_EQ(Barrier->arg_size(), 2U);
462-
EXPECT_EQ(Barrier->getCalledFunction()->getName(), "__kmpc_cancel_barrier");
463-
EXPECT_FALSE(Barrier->getCalledFunction()->doesNotAccessMemory());
464-
EXPECT_FALSE(Barrier->getCalledFunction()->doesNotFreeMemory());
465-
EXPECT_TRUE(Barrier->use_empty());
452+
EXPECT_EQ(CancelBBTI->getSuccessor(1)->size(), 1U);
466453
EXPECT_EQ(CancelBBTI->getSuccessor(1)->getTerminator()->getNumSuccessors(),
467454
1U);
468-
EXPECT_EQ(CancelBBTI->getSuccessor(1)->getTerminator()->getSuccessor(0), CBB);
455+
// cancel branch instruction (1) -> .cncl -> .fini -> CBB
456+
EXPECT_EQ(CancelBBTI->getSuccessor(1)
457+
->getTerminator()
458+
->getSuccessor(0)
459+
->getTerminator()
460+
->getSuccessor(0),
461+
CBB);
469462

470463
EXPECT_EQ(cast<CallInst>(Cancel)->getArgOperand(1), GTID);
471464

@@ -497,8 +490,8 @@ TEST_F(OpenMPIRBuilderTest, CreateCancelIfCond) {
497490
OMPBuilder.createCancel(Loc, Builder.getTrue(), OMPD_parallel));
498491
Builder.restoreIP(NewIP);
499492
EXPECT_FALSE(M->global_empty());
500-
EXPECT_EQ(M->size(), 4U);
501-
EXPECT_EQ(F->size(), 7U);
493+
EXPECT_EQ(M->size(), 3U);
494+
EXPECT_EQ(F->size(), 8U);
502495
EXPECT_EQ(BB->size(), 1U);
503496
ASSERT_TRUE(isa<BranchInst>(BB->getTerminator()));
504497
ASSERT_EQ(BB->getTerminator()->getNumSuccessors(), 2U);
@@ -524,23 +517,15 @@ TEST_F(OpenMPIRBuilderTest, CreateCancelIfCond) {
524517
EXPECT_EQ(CancelBBTI->getSuccessor(0)->size(), 1U);
525518
EXPECT_EQ(CancelBBTI->getSuccessor(0)->getUniqueSuccessor(),
526519
NewIP.getBlock());
527-
EXPECT_EQ(CancelBBTI->getSuccessor(1)->size(), 3U);
528-
CallInst *GTID1 = dyn_cast<CallInst>(&CancelBBTI->getSuccessor(1)->front());
529-
EXPECT_NE(GTID1, nullptr);
530-
EXPECT_EQ(GTID1->arg_size(), 1U);
531-
EXPECT_EQ(GTID1->getCalledFunction()->getName(), "__kmpc_global_thread_num");
532-
EXPECT_FALSE(GTID1->getCalledFunction()->doesNotAccessMemory());
533-
EXPECT_FALSE(GTID1->getCalledFunction()->doesNotFreeMemory());
534-
CallInst *Barrier = dyn_cast<CallInst>(GTID1->getNextNode());
535-
EXPECT_NE(Barrier, nullptr);
536-
EXPECT_EQ(Barrier->arg_size(), 2U);
537-
EXPECT_EQ(Barrier->getCalledFunction()->getName(), "__kmpc_cancel_barrier");
538-
EXPECT_FALSE(Barrier->getCalledFunction()->doesNotAccessMemory());
539-
EXPECT_FALSE(Barrier->getCalledFunction()->doesNotFreeMemory());
540-
EXPECT_TRUE(Barrier->use_empty());
520+
EXPECT_EQ(CancelBBTI->getSuccessor(1)->size(), 1U);
541521
EXPECT_EQ(CancelBBTI->getSuccessor(1)->getTerminator()->getNumSuccessors(),
542522
1U);
543-
EXPECT_EQ(CancelBBTI->getSuccessor(1)->getTerminator()->getSuccessor(0), CBB);
523+
EXPECT_EQ(CancelBBTI->getSuccessor(1)
524+
->getTerminator()
525+
->getSuccessor(0)
526+
->getTerminator()
527+
->getSuccessor(0),
528+
CBB);
544529

545530
EXPECT_EQ(cast<CallInst>(Cancel)->getArgOperand(1), GTID);
546531

@@ -572,7 +557,7 @@ TEST_F(OpenMPIRBuilderTest, CreateCancelBarrier) {
572557
Builder.restoreIP(NewIP);
573558
EXPECT_FALSE(M->global_empty());
574559
EXPECT_EQ(M->size(), 3U);
575-
EXPECT_EQ(F->size(), 4U);
560+
EXPECT_EQ(F->size(), 5U);
576561
EXPECT_EQ(BB->size(), 4U);
577562

578563
CallInst *GTID = dyn_cast<CallInst>(&BB->front());
@@ -595,7 +580,11 @@ TEST_F(OpenMPIRBuilderTest, CreateCancelBarrier) {
595580
EXPECT_EQ(BarrierBBTI->getSuccessor(1)->size(), 1U);
596581
EXPECT_EQ(BarrierBBTI->getSuccessor(1)->getTerminator()->getNumSuccessors(),
597582
1U);
598-
EXPECT_EQ(BarrierBBTI->getSuccessor(1)->getTerminator()->getSuccessor(0),
583+
EXPECT_EQ(BarrierBBTI->getSuccessor(1)
584+
->getTerminator()
585+
->getSuccessor(0)
586+
->getTerminator()
587+
->getSuccessor(0),
599588
CBB);
600589

601590
EXPECT_EQ(cast<CallInst>(Barrier)->getArgOperand(1), GTID);
@@ -1291,8 +1280,8 @@ TEST_F(OpenMPIRBuilderTest, ParallelCancelBarrier) {
12911280

12921281
EXPECT_EQ(NumBodiesGenerated, 1U);
12931282
EXPECT_EQ(NumPrivatizedVars, 0U);
1294-
EXPECT_EQ(NumFinalizationPoints, 2U);
1295-
EXPECT_TRUE(FakeDestructor->hasNUses(2));
1283+
EXPECT_EQ(NumFinalizationPoints, 1U);
1284+
EXPECT_TRUE(FakeDestructor->hasNUses(1));
12961285

12971286
Builder.restoreIP(AfterIP);
12981287
Builder.CreateRetVoid();

0 commit comments

Comments
 (0)