[OMPIRBuilder] Fix module finalization

[domada]

Summary

OMP offload module metadata should be created only when module generation is finalized. If we finalize LLVM IR function we should not create omp offload metadata.

clang/lib/CodeGen/CodeGenFunction.cpp

if (getLangOpts().OpenMP && CurFn)
     CGM.getOpenMPRuntime().functionFinished(*this);
 
   // If we have an OpenMPIRBuilder we want to finalize functions (incl.
   // outlining etc) at some point. Doing it once the function codegen is done
   // seems to be a reasonable spot. We do it here, as opposed to the deletion
   // time of the CodeGenModule, because we have to ensure the IR has not yet
   // been "emitted" to the outside, thus, modifications are still sensible.
   if (CGM.getLangOpts().OpenMPIRBuilder && CurFn)
-    CGM.getOpenMPRuntime().getOMPBuilder().finalize(CurFn);
+    CGM.getOpenMPRuntime().getOMPBuilder().finalizeFunction(CurFn);
 }
 
 // Map the LangOption for exception behavior into
 // the corresponding enum in the IR.
 llvm::fp::ExceptionBehavior
 clang::ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind) {
 
   switch (Kind) {

clang/test/OpenMP/irbuilder_omp_offload_metadata.c

+// This test checks if OpenMPIRBuilder generates the same number of omp offload
+// info nodes as Clang does. The wrong number of metadata nodes can provide
+// miscompilation of the device code for enabled OpenMPIRBuilder
+// RUN: %clang_cc1 -triple x86_64--unknown-linux-gnu -emit-llvm -fopenmp -fopenmp-enable-irbuilder -fopenmp-targets=amdgcn-amd-amdhsa -faddrsig  %s -o - | FileCheck --check-prefix BUILDER %s
+// RUN: %clang_cc1 -triple x86_64--unknown-linux-gnu -emit-llvm -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa -faddrsig  %s -o - | FileCheck --check-prefix NOBUILDER %s
+
+void omp_offload_metadata_irbuilder_test() {
+int a[256];
+#pragma omp target parallel for
+  for (int i = 0; i < 256; i++) {
+    a[i] = i;
+  }
+}
+
+//BUILDER: !omp_offload.info = !{!{{[0-9]+}}}
+//NOBUILDER: !omp_offload.info = !{!{{[0-9]+}}}

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

public:
   /// passed in as the HostFilePath argument.
   /// \param HostFilePath The path to the host IR file, used to load in
   /// offload metadata for the device, allowing host and device to
   /// maintain the same metadata mapping.
   void initialize(StringRef HostFilePath = {});
 
   void setConfig(OpenMPIRBuilderConfig C) { Config = C; }
 
-  /// Finalize the underlying module, e.g., by outlining regions.
+  /// Finalize the underlying function, e.g., by outlining regions.
   /// \param Fn                    The function to be finalized. If not used,
   ///                              all functions are finalized.
-  void finalize(Function *Fn = nullptr);
+  void finalizeFunction(Function *Fn = nullptr);
+
+  /// Finalize the underlying module. Finalize all functions and create
+  /// offload metadata for the module
+  void finalizeModule();
 
   /// Add attributes known for \p FnID to \p Fn.
   void addAttributes(omp::RuntimeFunction FnID, Function &Fn);
 
   /// Type used throughout for insertion points.
   using InsertPointTy = IRBuilder<>::InsertPoint;
 
   /// Get the create a name using the platform specific separators.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

if (std::error_code Err = M.getError()) {
     report_fatal_error(
         ("error parsing host file inside of OpenMPIRBuilder: " + Err.message())
             .c_str());
   }
 
   loadOffloadInfoMetadata(*M.get());
 }
 
-void OpenMPIRBuilder::finalize(Function *Fn) {
+void OpenMPIRBuilder::finalizeFunction(Function *Fn) {
   SmallPtrSet<BasicBlock *, 32> ParallelRegionBlockSet;
   SmallVector<BasicBlock *, 32> Blocks;
   SmallVector<OutlineInfo, 16> DeferredOutlines;
   for (OutlineInfo &OI : OutlineInfos) {
     // Skip functions that have not finalized yet; may happen with nested
     // function generation.
     if (Fn && OI.getFunction() != Fn) {
       DeferredOutlines.push_back(OI);
for (OutlineInfo &OI : OutlineInfos) {
 
     // Run a user callback, e.g. to add attributes.
     if (OI.PostOutlineCB)
       OI.PostOutlineCB(*OutlinedFn);
   }
 
   // Remove work items that have been completed.
   OutlineInfos = std::move(DeferredOutlines);
+}
 
+void OpenMPIRBuilder::finalizeModule() {
+  finalizeFunction();
   EmitMetadataErrorReportFunctionTy &&ErrorReportFn =
       [](EmitMetadataErrorKind Kind,
          const TargetRegionEntryInfo &EntryInfo) -> void {
     errs() << "Error of kind: " << Kind
            << " when emitting offload entries and metadata during "
               "OMPIRBuilder finalization \n";
   };
 
void OpenMPIRBuilder::createOffloadEntriesAndInfoMetadata(
   // Auxiliary methods to create metadata values and strings.
   auto &&GetMDInt = [this](unsigned V) {
     return ConstantAsMetadata::get(ConstantInt::get(Builder.getInt32Ty(), V));
   };
 
   auto &&GetMDString = [&C](StringRef V) { return MDString::get(C, V); };
 
   // Create the offloading info metadata node.
-  NamedMDNode *MD = M.getOrInsertNamedMetadata("omp_offload.info");
+  NamedMDNode *MD = M.getOrInsertNamedMetadata(ompOffloadInfoName);
   auto &&TargetRegionMetadataEmitter =
       [&C, MD, &OrderedEntries, &GetMDInt, &GetMDString](
           const TargetRegionEntryInfo &EntryInfo,
           const OffloadEntriesInfoManager::OffloadEntryInfoTargetRegion &E) {
         // Generate metadata for target regions. Each entry of this metadata
         // contains:
         // - Entry 0 -> Kind of this type of metadata (0).
         // - Entry 1 -> Device ID of the file where the entry was identified.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

auto Merge = [&](const SmallVectorImpl<CallInst *> &MergableCIs,
       // Create the merged parallel region with default proc binding, to
       // avoid overriding binding settings, and without explicit cancellation.
       InsertPointTy AfterIP = OMPInfoCache.OMPBuilder.createParallel(
           Loc, AllocaIP, BodyGenCB, PrivCB, FiniCB, nullptr, nullptr,
           OMP_PROC_BIND_default, /* IsCancellable */ false);
       BranchInst::Create(AfterBB, AfterIP.getBlock());
 
       // Perform the actual outlining.
-      OMPInfoCache.OMPBuilder.finalize(OriginalFn);
+      OMPInfoCache.OMPBuilder.finalizeFunction(OriginalFn);
 
       Function *OutlinedFn = MergableCIs.front()->getCaller();
 
       // Replace the __kmpc_fork_call calls with direct calls to the outlined
       // callbacks.
       SmallVector<Value *, 8> Args;
       for (auto *CI : MergableCIs) {
         Value *Callee = CI->getArgOperand(CallbackCalleeOperand);

llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

IRBuilder<>::InsertPoint AfterIP =
                                 nullptr, nullptr, OMP_PROC_BIND_default, false);
   EXPECT_EQ(NumBodiesGenerated, 1U);
   EXPECT_EQ(NumPrivatizedVars, 1U);
   EXPECT_EQ(NumFinalizationPoints, 1U);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_NE(PrivAI, nullptr);
   Function *OutlinedFn = PrivAI->getFunction();
   EXPECT_NE(F, OutlinedFn);
   EXPECT_FALSE(verifyModule(*M, &errs()));
   EXPECT_TRUE(OutlinedFn->hasFnAttribute(Attribute::NoUnwind));
   EXPECT_TRUE(OutlinedFn->hasFnAttribute(Attribute::NoRecurse));
   EXPECT_TRUE(OutlinedFn->hasParamAttribute(0, Attribute::NoAlias));
TEST_F(OpenMPIRBuilderTest, ParallelNested) {
 
   EXPECT_EQ(NumInnerBodiesGenerated, 1U);
   EXPECT_EQ(NumOuterBodiesGenerated, 1U);
   EXPECT_EQ(NumFinalizationPoints, 2U);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_EQ(M->size(), 5U);
   for (Function &OutlinedFn : *M) {
     if (F == &OutlinedFn || OutlinedFn.isDeclaration())
       continue;
     EXPECT_FALSE(verifyModule(*M, &errs()));
     EXPECT_TRUE(OutlinedFn.hasFnAttribute(Attribute::NoUnwind));
     EXPECT_TRUE(OutlinedFn.hasFnAttribute(Attribute::NoRecurse));
TEST_F(OpenMPIRBuilderTest, ParallelNested2Inner) {
 
   EXPECT_EQ(NumInnerBodiesGenerated, 2U);
   EXPECT_EQ(NumOuterBodiesGenerated, 1U);
   EXPECT_EQ(NumFinalizationPoints, 3U);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_EQ(M->size(), 6U);
   for (Function &OutlinedFn : *M) {
     if (F == &OutlinedFn || OutlinedFn.isDeclaration())
       continue;
     EXPECT_FALSE(verifyModule(*M, &errs()));
     EXPECT_TRUE(OutlinedFn.hasFnAttribute(Attribute::NoUnwind));
     EXPECT_TRUE(OutlinedFn.hasFnAttribute(Attribute::NoRecurse));
IRBuilder<>::InsertPoint AfterIP =
                                 nullptr, OMP_PROC_BIND_default, false);
 
   EXPECT_EQ(NumBodiesGenerated, 1U);
   EXPECT_EQ(NumPrivatizedVars, 1U);
   EXPECT_EQ(NumFinalizationPoints, 1U);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_NE(PrivAI, nullptr);
   Function *OutlinedFn = PrivAI->getFunction();
   EXPECT_NE(F, OutlinedFn);
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_TRUE(OutlinedFn->hasInternalLinkage());
   EXPECT_EQ(OutlinedFn->arg_size(), 3U);
TEST_F(OpenMPIRBuilderTest, ParallelCancelBarrier) {
 
   EXPECT_EQ(NumBodiesGenerated, 1U);
   EXPECT_EQ(NumPrivatizedVars, 0U);
   EXPECT_EQ(NumFinalizationPoints, 2U);
   EXPECT_EQ(FakeDestructor->getNumUses(), 2U);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   BasicBlock *ExitBB = nullptr;
   for (const User *Usr : FakeDestructor->users()) {
     const CallInst *CI = dyn_cast<CallInst>(Usr);
     ASSERT_EQ(CI->getCalledFunction(), FakeDestructor);
     ASSERT_TRUE(isa<BranchInst>(CI->getNextNode()));
TEST_F(OpenMPIRBuilderTest, ParallelForwardAsPointers) {
   IRBuilder<>::InsertPoint AllocaIP(&F->getEntryBlock(),
                                     F->getEntryBlock().getFirstInsertionPt());
   IRBuilder<>::InsertPoint AfterIP =
       OMPBuilder.createParallel(Loc, AllocaIP, BodyGenCB, PrivCB, FiniCB,
                                 nullptr, nullptr, OMP_PROC_BIND_default, false);
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
   Function *OutlinedFn = Internal->getFunction();
 
   Type *Arg2Type = OutlinedFn->getArg(2)->getType();
   EXPECT_TRUE(Arg2Type->isPointerTy());
 }
 
SplitBlockAndInsertIfThenElse(Cmp, CodeGenIP.getBlock()->getTerminator(),
                                   &ThenTerm, &ElseTerm);
   };
 
   CanonicalLoopInfo *Loop =
       OMPBuilder.createCanonicalLoop(Loc, LoopBodyGenCB, TripCount);
 
   Builder.restoreIP(Loop->getAfterIP());
   ReturnInst *RetInst = Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   Loop->assertOK();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_EQ(NumBodiesGenerated, 1U);
 
   // Verify control flow structure (in addition to Loop->assertOK()).
   EXPECT_EQ(Loop->getPreheader()->getSinglePredecessor(), &F->getEntryBlock());
TEST_F(OpenMPIRBuilderTest, CanonicalLoopBounds) {
   EXPECT_EQ(EvalTripCount(0, INT16_MIN, -1, true, false), 0x8000);
   EXPECT_EQ(EvalTripCount(0, INT16_MIN, -16, true, false), 0x800);
   EXPECT_EQ(EvalTripCount(0x7FFF, INT16_MIN, -1, true, false), 0xFFFF);
   EXPECT_EQ(EvalTripCount(0x7FFF, 1, INT16_MIN, true, false), 1);
   EXPECT_EQ(EvalTripCount(0x7FFF, -1, INT16_MIN, true, true), 2);
 
   // Finalize the function and verify it.
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, CollapseNestedLoops) {
   using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
TEST_F(OpenMPIRBuilderTest, CollapseNestedLoops) {
 
   // Finish the function.
   Builder.restoreIP(OuterLoop->getAfterIP());
   Builder.CreateRetVoid();
 
   CanonicalLoopInfo *Collapsed =
       OMPBuilder.collapseLoops(DL, {OuterLoop, InnerLoop}, ComputeIP);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   // Verify control flow and BB order.
   BasicBlock *RefOrder[] = {
       Collapsed->getPreheader(),   Collapsed->getHeader(),
       Collapsed->getCond(),        Collapsed->getBody(),
       InbetweenLead->getParent(),  Call->getParent(),
       InbetweenTrail->getParent(), Collapsed->getLatch(),
TEST_F(OpenMPIRBuilderTest, TileSingleLoop) {
   Instruction *OrigIndVar = Loop->getIndVar();
   EXPECT_EQ(Call->getOperand(1), OrigIndVar);
 
   // Tile the loop.
   Constant *TileSize = ConstantInt::get(Loop->getIndVarType(), APInt(32, 7));
   std::vector<CanonicalLoopInfo *> GenLoops =
       OMPBuilder.tileLoops(DL, {Loop}, {TileSize});
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_EQ(GenLoops.size(), 2u);
   CanonicalLoopInfo *Floor = GenLoops[0];
   CanonicalLoopInfo *Tile = GenLoops[1];
 
   BasicBlock *RefOrder[] = {
       Floor->getPreheader(), Floor->getHeader(),   Floor->getCond(),
TEST_F(OpenMPIRBuilderTest, TileNestedLoops) {
   Builder.CreateRetVoid();
 
   // Tile to loop nest.
   Constant *OuterTileSize = ConstantInt::get(LCTy, APInt(32, 11));
   Constant *InnerTileSize = ConstantInt::get(LCTy, APInt(32, 7));
   std::vector<CanonicalLoopInfo *> GenLoops = OMPBuilder.tileLoops(
       DL, {OuterLoop, InnerLoop}, {OuterTileSize, InnerTileSize});
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_EQ(GenLoops.size(), 4u);
   CanonicalLoopInfo *Floor1 = GenLoops[0];
   CanonicalLoopInfo *Floor2 = GenLoops[1];
   CanonicalLoopInfo *Tile1 = GenLoops[2];
   CanonicalLoopInfo *Tile2 = GenLoops[3];
 
TEST_F(OpenMPIRBuilderTest, TileNestedLoopsWithBounds) {
   Builder.CreateRetVoid();
 
   // Tile the loop nest.
   Constant *TileSize0 = ConstantInt::get(LCTy, APInt(32, 11));
   Constant *TileSize1 = ConstantInt::get(LCTy, APInt(32, 7));
   std::vector<CanonicalLoopInfo *> GenLoops =
       OMPBuilder.tileLoops(DL, {OuterLoop, InnerLoop}, {TileSize0, TileSize1});
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_EQ(GenLoops.size(), 4u);
   CanonicalLoopInfo *Floor0 = GenLoops[0];
   CanonicalLoopInfo *Floor1 = GenLoops[1];
   CanonicalLoopInfo *Tile0 = GenLoops[2];
   CanonicalLoopInfo *Tile1 = GenLoops[3];
 
TEST_F(OpenMPIRBuilderTest, TileSingleLoopCounts) {
   EXPECT_EQ(GetFloorCount(0, 0xFFFE, 1, false, true, 7), 0xFFFFu / 7 + 1);
   EXPECT_EQ(GetFloorCount(-0x8000, 0x7FFF, 1, true, false, 7), 0xFFFFu / 7 + 1);
   EXPECT_EQ(GetFloorCount(-0x7FFF, 0x7FFF, 1, true, true, 7), 0xFFFFu / 7 + 1);
   EXPECT_EQ(GetFloorCount(0, 0xFFFE, 1, false, false, 0xFFFF), 1u);
   EXPECT_EQ(GetFloorCount(-0x8000, 0x7FFF, 1, true, false, 0xFFFF), 1u);
 
   // Finalize the function.
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, ApplySimd) {
   OpenMPIRBuilder OMPBuilder(*M);
   MapVector<Value *, Value *> AlignedVars;
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Simd-ize the loop.
   OMPBuilder.applySimd(CLI, AlignedVars, /* IfCond */ nullptr,
                        OrderKind::OMP_ORDER_unknown,
                        /* Simdlen */ nullptr,
                        /* Safelen */ nullptr);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySimdCustomAligned) {
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Simd-ize the loop.
   OMPBuilder.applySimd(CLI, AlignedVars, /* IfCond */ nullptr,
                        OrderKind::OMP_ORDER_unknown,
                        /* Simdlen */ nullptr,
                        /* Safelen */ nullptr);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySimdlen) {
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Simd-ize the loop.
   OMPBuilder.applySimd(CLI, AlignedVars,
                        /* IfCond */ nullptr, OrderKind::OMP_ORDER_unknown,
                        ConstantInt::get(Type::getInt32Ty(Ctx), 3),
                        /* Safelen */ nullptr);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySafelenOrderConcurrent) {
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Simd-ize the loop.
   OMPBuilder.applySimd(
       CLI, AlignedVars, /* IfCond */ nullptr, OrderKind::OMP_ORDER_concurrent,
       /* Simdlen */ nullptr, ConstantInt::get(Type::getInt32Ty(Ctx), 3));
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySafelen) {
   MapVector<Value *, Value *> AlignedVars;
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   OMPBuilder.applySimd(
       CLI, AlignedVars, /* IfCond */ nullptr, OrderKind::OMP_ORDER_unknown,
       /* Simdlen */ nullptr, ConstantInt::get(Type::getInt32Ty(Ctx), 3));
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySimdlenSafelen) {
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   OMPBuilder.applySimd(CLI, AlignedVars, /* IfCond */ nullptr,
                        OrderKind::OMP_ORDER_unknown,
                        ConstantInt::get(Type::getInt32Ty(Ctx), 2),
                        ConstantInt::get(Type::getInt32Ty(Ctx), 3));
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_F(OpenMPIRBuilderTest, ApplySimdLoopIf) {
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Simd-ize the loop with if condition
   OMPBuilder.applySimd(CLI, AlignedVars, IfCmp, OrderKind::OMP_ORDER_unknown,
                        ConstantInt::get(Type::getInt32Ty(Ctx), 3),
                        /* Safelen */ nullptr);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   // Check if there are two loops (one with enabled vectorization)

 TEST_F(OpenMPIRBuilderTest, UnrollLoopFull) {
   OpenMPIRBuilder OMPBuilder(*M);
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Unroll the loop.
   OMPBuilder.unrollLoopFull(DL, CLI);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
   EXPECT_EQ(TopLvl.size(), 1u);
 
   Loop *L = TopLvl.front();
   EXPECT_TRUE(getBooleanLoopAttribute(L, "llvm.loop.unroll.enable"));
   EXPECT_TRUE(getBooleanLoopAttribute(L, "llvm.loop.unroll.full"));
 }
 
 TEST_F(OpenMPIRBuilderTest, UnrollLoopPartial) {
   OpenMPIRBuilder OMPBuilder(*M);
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Unroll the loop.
   CanonicalLoopInfo *UnrolledLoop = nullptr;
   OMPBuilder.unrollLoopPartial(DL, CLI, 5, &UnrolledLoop);
   ASSERT_NE(UnrolledLoop, nullptr);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
   UnrolledLoop->assertOK();
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 

 TEST_F(OpenMPIRBuilderTest, UnrollLoopHeuristic) {
   OpenMPIRBuilder OMPBuilder(*M);
 
   CanonicalLoopInfo *CLI = buildSingleLoopFunction(DL, OMPBuilder, 32);
 
   // Unroll the loop.
   OMPBuilder.unrollLoopHeuristic(DL, CLI);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   PassBuilder PB;
   FunctionAnalysisManager FAM;
   PB.registerFunctionAnalyses(FAM);
   LoopInfo &LI = FAM.getResult<LoopAnalysis>(*F);
 
   const std::vector<Loop *> &TopLvl = LI.getTopLevelLoops();
TEST_P(OpenMPIRBuilderTestWithIVBits, StaticChunkedWorkshareLoop) {
 
   Type *LCTy = Type::getInt32Ty(Ctx);
   Value *ChunkSize = ConstantInt::get(LCTy, 5);
   InsertPointTy AllocaIP{&F->getEntryBlock(),
                          F->getEntryBlock().getFirstInsertionPt()};
   OMPBuilder.applyWorkshareLoop(DL, CLI, AllocaIP, /*NeedsBarrier=*/true,
                                 OMP_SCHEDULE_Static, ChunkSize);
 
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   BasicBlock *Entry = &F->getEntryBlock();
   BasicBlock *Preheader = Entry->getSingleSuccessor();
 
   BasicBlock *DispatchPreheader = Preheader->getSingleSuccessor();
   BasicBlock *DispatchHeader = DispatchPreheader->getSingleSuccessor();
   BasicBlock *DispatchCond = DispatchHeader->getSingleSuccessor();
TEST_P(OpenMPIRBuilderTestWithParams, DynamicWorkShareLoop) {
   // the thread ID.
   size_t NumCallsInExitBlock =
       count_if(*ExitBlock, [](Instruction &I) { return isa<CallInst>(I); });
   EXPECT_EQ(NumCallsInExitBlock, 2u);
 
   // Add a termination to our block and check that it is internally consistent.
   Builder.restoreIP(EndIP);
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 INSTANTIATE_TEST_SUITE_P(
     OpenMPWSLoopSchedulingTypes, OpenMPIRBuilderTestWithParams,
     ::testing::Values(omp::OMPScheduleType::UnorderedDynamicChunked,
                       omp::OMPScheduleType::UnorderedGuidedChunked,
                       omp::OMPScheduleType::UnorderedAuto,
InsertPointTy EndIP = OMPBuilder.applyWorkshareLoop(
       DL, CLI, AllocaIP, /*NeedsBarrier=*/true, OMP_SCHEDULE_Static, ChunkVal,
       /*HasSimdModifier=*/false, /*HasMonotonicModifier=*/false,
       /*HasNonmonotonicModifier=*/false,
       /*HasOrderedClause=*/true);
 
   // Add a termination to our block and check that it is internally consistent.
   Builder.restoreIP(EndIP);
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   CallInst *InitCall = nullptr;
   for (Instruction &EI : *Preheader) {
     Instruction *Cur = &EI;
     if (isa<CallInst>(Cur)) {
       InitCall = cast<CallInst>(Cur);
       if (InitCall->getCalledFunction()->getName() == "__kmpc_dispatch_init_4u")
TEST_F(OpenMPIRBuilderTest, OrderedDirectiveDependSource) {
   StoreValues.emplace_back(ConstantInt::get(LCTy, 2));
 
   // Test for "#omp ordered depend(source)"
   Builder.restoreIP(OMPBuilder.createOrderedDepend(Builder, AllocaIP, NumLoops,
                                                    StoreValues, ".cnt.addr",
                                                    /*IsDependSource=*/true));
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   AllocaInst *AllocInst = dyn_cast<AllocaInst>(&BB->front());
   ASSERT_NE(AllocInst, nullptr);
   ArrayType *ArrType = dyn_cast<ArrayType>(AllocInst->getAllocatedType());
   EXPECT_EQ(ArrType->getNumElements(), NumLoops);
   EXPECT_TRUE(
       AllocInst->getAllocatedType()->getArrayElementType()->isIntegerTy(64));
TEST_F(OpenMPIRBuilderTest, OrderedDirectiveDependSink) {
   StoreValues.emplace_back(ConstantInt::get(LCTy, 2));
 
   // Test for "#omp ordered depend(sink: vec)"
   Builder.restoreIP(OMPBuilder.createOrderedDepend(Builder, AllocaIP, NumLoops,
                                                    StoreValues, ".cnt.addr",
                                                    /*IsDependSource=*/false));
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   AllocaInst *AllocInst = dyn_cast<AllocaInst>(&BB->front());
   ASSERT_NE(AllocInst, nullptr);
   ArrayType *ArrType = dyn_cast<ArrayType>(AllocInst->getAllocatedType());
   EXPECT_EQ(ArrType->getNumElements(), NumLoops);
   EXPECT_TRUE(
       AllocInst->getAllocatedType()->getArrayElementType()->isIntegerTy(64));
TEST_F(OpenMPIRBuilderTest, OrderedDirectiveThreads) {
   };
 
   // Test for "#omp ordered [threads]"
   BasicBlock *EntryBB = Builder.GetInsertBlock();
   Builder.restoreIP(
       OMPBuilder.createOrderedThreadsSimd(Builder, BodyGenCB, FiniCB, true));
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_NE(EntryBB->getTerminator(), nullptr);
 
   CallInst *OrderedEntryCI = nullptr;
   for (auto &EI : *EntryBB) {
     Instruction *Cur = &EI;
     if (isa<CallInst>(Cur)) {
TEST_F(OpenMPIRBuilderTest, OrderedDirectiveSimd) {
   };
 
   // Test for "#omp ordered simd"
   BasicBlock *EntryBB = Builder.GetInsertBlock();
   Builder.restoreIP(
       OMPBuilder.createOrderedThreadsSimd(Builder, BodyGenCB, FiniCB, false));
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   EXPECT_NE(EntryBB->getTerminator(), nullptr);
 
   CallInst *OrderedEntryCI = nullptr;
   for (auto &EI : *EntryBB) {
     Instruction *Cur = &EI;
     if (isa<CallInst>(Cur)) {
TEST_F(OpenMPIRBuilderTest, OMPAtomicReadFlt) {
   EXPECT_EQ(CastToFlt->getDestTy(), Float32);
   EXPECT_EQ(CastToFlt->getOperand(0), AtomicLoad);
 
   StoreInst *StoreofAtomic = cast<StoreInst>(CastToFlt->getNextNode());
   EXPECT_EQ(StoreofAtomic->getValueOperand(), CastToFlt);
   EXPECT_EQ(StoreofAtomic->getPointerOperand(), VVal);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicReadInt) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicReadInt) {
 
   EXPECT_NE(AtomicLoad, nullptr);
   EXPECT_TRUE(AtomicLoad->isAtomic());
 
   EXPECT_NE(StoreofAtomic, nullptr);
   EXPECT_EQ(StoreofAtomic->getValueOperand(), AtomicLoad);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicWriteFlt) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
TEST_F(OpenMPIRBuilderTest, OMPAtomicWriteFlt) {
   Value *ExprCast = Builder.CreateBitCast(ValToWrite, IntCastTy);
 
   StoreInst *StoreofAtomic = cast<StoreInst>(XVal->getNextNode());
   EXPECT_EQ(StoreofAtomic->getValueOperand(), ExprCast);
   EXPECT_EQ(StoreofAtomic->getPointerOperand(), XVal);
   EXPECT_TRUE(StoreofAtomic->isAtomic());
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicWriteInt) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
for (Instruction &Cur : *EntryBB) {
     }
   }
 
   EXPECT_NE(StoreofAtomic, nullptr);
   EXPECT_TRUE(StoreofAtomic->isAtomic());
   EXPECT_EQ(StoreofAtomic->getValueOperand(), ValToWrite);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdate) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdate) {
   EXPECT_EQ(CmpExchg->getCompareOperand(), Phi);
   EXPECT_EQ(CmpExchg->getSuccessOrdering(), AtomicOrdering::Monotonic);
 
   LoadInst *Ld = dyn_cast<LoadInst>(CmpExchg->getNewValOperand());
   EXPECT_NE(Ld, nullptr);
   EXPECT_EQ(UpdateTemp, Ld->getPointerOperand());
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdateFloat) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdateFloat) {
   EXPECT_EQ(CmpExchg->getPointerOperand(), XVal);
   EXPECT_EQ(CmpExchg->getCompareOperand(), Phi);
   EXPECT_EQ(CmpExchg->getSuccessOrdering(), AtomicOrdering::Monotonic);
 
   LoadInst *Ld = dyn_cast<LoadInst>(CmpExchg->getNewValOperand());
   EXPECT_NE(Ld, nullptr);
   EXPECT_EQ(UpdateTemp, Ld->getPointerOperand());
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdateIntr) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicUpdateIntr) {
   EXPECT_EQ(CmpExchg->getCompareOperand(), Phi);
   EXPECT_EQ(CmpExchg->getSuccessOrdering(), AtomicOrdering::Monotonic);
 
   LoadInst *Ld = dyn_cast<LoadInst>(CmpExchg->getNewValOperand());
   EXPECT_NE(Ld, nullptr);
   EXPECT_EQ(UpdateTemp, Ld->getPointerOperand());
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicCapture) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicCapture) {
   EXPECT_NE(ARWM, nullptr);
   EXPECT_EQ(ARWM->getPointerOperand(), XVal);
   EXPECT_EQ(ARWM->getOperation(), RMWOp);
   StoreInst *St = dyn_cast<StoreInst>(ARWM->user_back());
   EXPECT_NE(St, nullptr);
   EXPECT_EQ(St->getPointerOperand(), VVal);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicCompare) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicCompare) {
 
   AtomicCmpXchgInst *AXCHG = dyn_cast<AtomicCmpXchgInst>(ARWM2->getNextNode());
   EXPECT_NE(AXCHG, nullptr);
   EXPECT_EQ(AXCHG->getPointerOperand(), XVal);
   EXPECT_EQ(AXCHG->getCompareOperand(), Expr);
   EXPECT_EQ(AXCHG->getNewValOperand(), D);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, OMPAtomicCompareCapture) {
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
TEST_F(OpenMPIRBuilderTest, OMPAtomicCompareCapture) {
   EXPECT_EQ(Sel2->getTrueValue(), Expr);
   EXPECT_EQ(Sel2->getFalseValue(), ARWM2);
   StoreInst *Store8 = dyn_cast<StoreInst>(Sel2->getNextNode());
   EXPECT_NE(Store8, nullptr);
   EXPECT_EQ(Store8->getPointerOperand(), VVal);
   EXPECT_EQ(Store8->getValueOperand(), Sel2);
 
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 /// Returns the single instruction of InstTy type in BB that uses the value V.
 /// If there is more than one such instruction, returns null.
 template <typename InstTy>
 static InstTy *findSingleUserInBlock(Value *V, BasicBlock *BB) {
   InstTy *Result = nullptr;
OpenMPIRBuilder::ReductionInfo ReductionInfos[] = {
       {SumType, SumReduced, SumPrivatized, sumReduction, sumAtomicReduction},
       {XorType, XorReduced, XorPrivatized, xorReduction, xorAtomicReduction}};
 
   OMPBuilder.createReductions(BodyIP, BodyAllocaIP, ReductionInfos);
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize(F);
+  OMPBuilder.finalizeFunction(F);
 
   // The IR must be valid.
   EXPECT_FALSE(verifyModule(*M));
 
   // Outlining must have happened.
   SmallVector<CallInst *> ForkCalls;
   findCalls(F, omp::RuntimeFunction::OMPRTL___kmpc_fork_call, OMPBuilder,
             ForkCalls);
OMPBuilder.createReductions(
       {{SumType, SumReduced, SumPrivatized, sumReduction, sumAtomicReduction}});
   OMPBuilder.createReductions(
       SecondBodyIP, SecondBodyAllocaIP,
       {{XorType, XorReduced, XorPrivatized, xorReduction, xorAtomicReduction}});
 
   Builder.restoreIP(AfterIP);
   Builder.CreateRetVoid();
 
-  OMPBuilder.finalize(F);
+  OMPBuilder.finalizeFunction(F);
 
   // The IR must be valid.
   EXPECT_FALSE(verifyModule(*M));
 
   // Two different outlined functions must have been created.
   SmallVector<CallInst *> ForkCalls;
   findCalls(F, omp::RuntimeFunction::OMPRTL___kmpc_fork_call, OMPBuilder,
             ForkCalls);
TEST_F(OpenMPIRBuilderTest, TargetRegion) {
   Inputs.push_back(APtr);
   Inputs.push_back(BPtr);
   Inputs.push_back(CPtr);
 
   TargetRegionEntryInfo EntryInfo("func", 42, 4711, 17);
   OpenMPIRBuilder::LocationDescription OmpLoc({Builder.saveIP(), DL});
   Builder.restoreIP(OMPBuilder.createTarget(OmpLoc, Builder.saveIP(), EntryInfo,
                                             -1, -1, Inputs, BodyGenCB));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   // Check the outlined call
   auto Iter = F->getEntryBlock().rbegin();
   CallInst *Call = dyn_cast<CallInst>(&*(++Iter));
   EXPECT_NE(Call, nullptr);
 
   // Check that the correct aguments are passed in
IRBuilder<>::InsertPoint EntryIP(&F->getEntryBlock(),
                                    F->getEntryBlock().getFirstInsertionPt());
   TargetRegionEntryInfo EntryInfo("parent", /*DeviceID=*/1, /*FileID=*/2,
                                   /*Line=*/3, /*Count=*/0);
 
   Builder.restoreIP(
       OMPBuilder.createTarget(Loc, EntryIP, EntryInfo, /*NumTeams=*/-1,
                               /*NumThreads=*/-1, CapturedArgs, BodyGenCB));
   Builder.CreateRetVoid();
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
 
   // Check outlined function
   EXPECT_FALSE(verifyModule(*M, &errs()));
   EXPECT_NE(TargetStore, nullptr);
   Function *OutlinedFn = TargetStore->getFunction();
   EXPECT_NE(F, OutlinedFn);
 
   EXPECT_TRUE(OutlinedFn->hasWeakODRLinkage());
TEST_F(OpenMPIRBuilderTest, CreateTask) {
 
   BasicBlock *AllocaBB = Builder.GetInsertBlock();
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   OpenMPIRBuilder::LocationDescription Loc(
       InsertPointTy(BodyBB, BodyBB->getFirstInsertionPt()), DL);
   Builder.restoreIP(OMPBuilder.createTask(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()),
       BodyGenCB));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   CallInst *TaskAllocCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc)
           ->user_back());
 
TEST_F(OpenMPIRBuilderTest, CreateTaskNoArgs) {
 
   BasicBlock *AllocaBB = Builder.GetInsertBlock();
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   OpenMPIRBuilder::LocationDescription Loc(
       InsertPointTy(BodyBB, BodyBB->getFirstInsertionPt()), DL);
   Builder.restoreIP(OMPBuilder.createTask(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()),
       BodyGenCB));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 }
 
 TEST_F(OpenMPIRBuilderTest, CreateTaskUntied) {
   using InsertPointTy = OpenMPIRBuilder::InsertPointTy;
   OpenMPIRBuilder OMPBuilder(*M);
   OMPBuilder.initialize();
   F->setName("func");
   IRBuilder<> Builder(BB);
   auto BodyGenCB = [&](InsertPointTy AllocaIP, InsertPointTy CodeGenIP) {};
   BasicBlock *AllocaBB = Builder.GetInsertBlock();
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   OpenMPIRBuilder::LocationDescription Loc(
       InsertPointTy(BodyBB, BodyBB->getFirstInsertionPt()), DL);
   Builder.restoreIP(OMPBuilder.createTask(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()), BodyGenCB,
       /*Tied=*/false));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   // Check for the `Tied` argument
   CallInst *TaskAllocCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc)
           ->user_back());
   ASSERT_NE(TaskAllocCall, nullptr);
   ConstantInt *Flags = dyn_cast<ConstantInt>(TaskAllocCall->getArgOperand(2));
TEST_F(OpenMPIRBuilderTest, CreateTaskDepend) {
   {
     OpenMPIRBuilder::DependData DDIn(RTLDependenceKindTy::DepIn,
                                      Type::getInt32Ty(M->getContext()), InDep);
     DDS.push_back(DDIn);
   }
   Builder.restoreIP(OMPBuilder.createTask(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()), BodyGenCB,
       /*Tied=*/false, /*Final*/ nullptr, /*IfCondition*/ nullptr, DDS));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   // Check for the `NumDeps` argument
   CallInst *TaskAllocCall = dyn_cast<CallInst>(
       OMPBuilder
           .getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_with_deps)
           ->user_back());
   ASSERT_NE(TaskAllocCall, nullptr);
TEST_F(OpenMPIRBuilderTest, CreateTaskFinal) {
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   Builder.SetInsertPoint(BodyBB);
   Value *Final = Builder.CreateICmp(
       CmpInst::Predicate::ICMP_EQ, F->getArg(0),
       ConstantInt::get(Type::getInt32Ty(M->getContext()), 0U));
   OpenMPIRBuilder::LocationDescription Loc(Builder.saveIP(), DL);
   Builder.restoreIP(OMPBuilder.createTask(Loc, AllocaIP, BodyGenCB,
                                           /*Tied=*/false, Final));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   // Check for the `Tied` argument
   CallInst *TaskAllocCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc)
           ->user_back());
   ASSERT_NE(TaskAllocCall, nullptr);
   BinaryOperator *OrInst =
TEST_F(OpenMPIRBuilderTest, CreateTaskIfCondition) {
   Builder.SetInsertPoint(BodyBB);
   Value *IfCondition = Builder.CreateICmp(
       CmpInst::Predicate::ICMP_EQ, F->getArg(0),
       ConstantInt::get(Type::getInt32Ty(M->getContext()), 0U));
   OpenMPIRBuilder::LocationDescription Loc(Builder.saveIP(), DL);
   Builder.restoreIP(OMPBuilder.createTask(Loc, AllocaIP, BodyGenCB,
                                           /*Tied=*/false, /*Final=*/nullptr,
                                           IfCondition));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   CallInst *TaskAllocCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_omp_task_alloc)
           ->user_back());
   ASSERT_NE(TaskAllocCall, nullptr);
TEST_F(OpenMPIRBuilderTest, CreateTaskgroup) {
 
   BasicBlock *AllocaBB = Builder.GetInsertBlock();
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   OpenMPIRBuilder::LocationDescription Loc(
       InsertPointTy(BodyBB, BodyBB->getFirstInsertionPt()), DL);
   Builder.restoreIP(OMPBuilder.createTaskgroup(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()),
       BodyGenCB));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   CallInst *TaskgroupCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_taskgroup)
           ->user_back());
   ASSERT_NE(TaskgroupCall, nullptr);
TEST_F(OpenMPIRBuilderTest, CreateTaskgroupWithTasks) {
 
   BasicBlock *AllocaBB = Builder.GetInsertBlock();
   BasicBlock *BodyBB = splitBB(Builder, /*CreateBranch=*/true, "alloca.split");
   OpenMPIRBuilder::LocationDescription Loc(
       InsertPointTy(BodyBB, BodyBB->getFirstInsertionPt()), DL);
   Builder.restoreIP(OMPBuilder.createTaskgroup(
       Loc, InsertPointTy(AllocaBB, AllocaBB->getFirstInsertionPt()),
       BodyGenCB));
-  OMPBuilder.finalize();
+  OMPBuilder.finalizeModule();
   Builder.CreateRetVoid();
 
   EXPECT_FALSE(verifyModule(*M, &errs()));
 
   CallInst *TaskgroupCall = dyn_cast<CallInst>(
       OMPBuilder.getOrCreateRuntimeFunctionPtr(OMPRTL___kmpc_taskgroup)
           ->user_back());
   ASSERT_NE(TaskgroupCall, nullptr);

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

: mlirModule(module), llvmModule(std::move(llvmModule)),
       typeTranslator(this->llvmModule->getContext()),
       iface(module->getContext()) {
   assert(satisfiesLLVMModule(mlirModule) &&
          "mlirModule should honor LLVM's module semantics.");
 }
 
 ModuleTranslation::~ModuleTranslation() {
   if (ompBuilder)
-    ompBuilder->finalize();
+    ompBuilder->finalizeModule();
 }
 
 void ModuleTranslation::forgetMapping(Region &region) {
   SmallVector<Region *> toProcess;
   toProcess.push_back(&region);
   while (!toProcess.empty()) {
     Region *current = toProcess.pop_back_val();
     for (Block &block : *current) {