[OpenMP] Use the OpenMP-IR-Builder

[jdoerfert]

Summary

This is the initial patch to use the OpenMP-IR-Builder, as discussed on
the mailing list ([1] and later) and at the US Dev Meeting'19.

The design is similar to D61953 but:

• placed in llvm/lib/IR/ next to IRBuilder, for lack of a better location.
• in a non-WIP status, with proper documentation and working.
• using a OpenMPKinds.def file to manage lists of directives, runtime functions, types, ..., similar to the current Clang implementation.
• restricted to handle only (simple) barriers, to implement most #pragma omp barrier directives and most implicit barriers.
• properly hooked into Clang to be used if possible.
• compatible with the remaining code generation.

Parts have been extracted into D69853 and D69785.

The plan is to have multiple people working on moving logic from Clang
here once the initial scaffolding landed.

[1] http://lists.flang-compiler.org/pipermail/flang-dev_lists.flang-compiler.org/2019-May/000197.html

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3489

createBarrier

clang/test/OpenMP/barrier_codegen.cpp

43

Remove #2, it may be changed

[jdoerfert]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3489

I'd say we align ourselves with the IRBuilder (which has CreateXXX methods) or we are different enough to avoid confusion, e.g., emitXXXX. I don't care much which way but createXXXX for one builder and CreateXXXX for another will be confusing, don't you think?

clang/test/OpenMP/barrier_codegen.cpp

43

Agreed, I even added an option to the update_test script to do so but forgot to use it (D68851).

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3489

Shall follow the LLVM coding document and format the new function name in accordance with it?

[jdoerfert]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3489

Changing the IRBuilder is something no one dared to do for years. I'm actually in favor but I would like to get this in rather sooner than later.

Two options I think are good:

• Use CreateXXX now and, if someone ever comes around to rename the Builder methods we rename them in all Builders.
• Use emitXXXX now to avoid confusion.

When someone in a review before asked for create instead of emit the reason was to be aligned with the IRBuilder. I think that is a good justification so I went with CreateXXX even if it is against the coding standard.

[jdoerfert]

Make the command line option shorter (mentioning openmp once should suffice)

[ABataev]

clang/include/clang/Driver/Options.td

1643–1644

Do we need to expose this option to driver or it is enough to have just a frontend option? If still need to have a driver option, add a test for driver.

[jdoerfert]

Update test attributes

[jdoerfert]

clang/include/clang/Driver/Options.td

1643–1644

How do I write a frontend option? Anything that we can query in the lib/CodeGen is fine with me. (I don't even need an option if we turn this on by default to get test coverage right away).

[ABataev]

clang/include/clang/Driver/Options.td

1643–1644

You nedd to move to CC1Options.td file. It means that you can't use it direcly when invoke the drive, instead you will need to use -Xclang -fopenmp-...

[jdoerfert]

Add driver test coverage

[ABataev]

clang/test/Driver/fopenmp.c

130–131

CHECK...-SAME?

clang/test/OpenMP/barrier_codegen.cpp

42

Not sure about correctness of inaccessiblemem_or_argmemonly attribute applied to this function. Are you sure about this? This is maybe true for the NVPTX/AMDGCN runtimes but not the generic version of libomp.

[jdoerfert]

clang/test/Driver/fopenmp.c

130–131

Sure, will do.

clang/test/OpenMP/barrier_codegen.cpp

42

Fair point. I'll remove it for now but we should come up with a scheme. Maybe communicating the target library and other information to the IRBuilder so we can select based on those.

[jdoerfert]

Adjust tests as requested

[ABataev]

clang/test/OpenMP/barrier_codegen.cpp

22

Not sure about correct use of nosync and readonly attributes. OpenMP runtime uses lazy initialization of the runtime library and when any runtime function is called, the inner parts of the OpenMP runtime are initialized automatically. It may use some sync primitives and may modify memory, I assume. Same about nofree.

[jdoerfert]

clang/test/OpenMP/barrier_codegen.cpp

22

There are two versions of these functions, host and device. I assume host functions are not inlined but device functions might be. This is basically all the modes we support right now.

If we do not inline the function (host) we don't necessarily care what they do but what effect the user can expect.
The user can not expect to synchronize through __kmpc_global_thread_num calls in a defined way, thus nosync.
Similarly, from the users perspective there is no way to determine if something was written or freed, no matter how many of these calls I issue and under which control conditions, all I see is the number as a result. Thus, readonly and nofree. I believe readnone is even fine here but it might not work for the device version (see below) so I removed it.

If we do inline the function (device) we need to make sure the attributes are compatible with the inlined code to not cause UB. The code of __kmpc_global_thread_num at least does not write anything and only reads stuff (as far as I can tell).

Please correct me if I overlooked something.

[ABataev]

clang/test/OpenMP/barrier_codegen.cpp

22

But someone may try to inline the host-based runtime or try to use LTO with it.
The question is not about the user expectations but about the optimizations which can be triggered with these attributes.

[jdoerfert]

clang/test/OpenMP/barrier_codegen.cpp

22

This is our runtime and we have supported and unsupported usage models.

[ABataev]

clang/test/OpenMP/barrier_codegen.cpp

22

Hmm, I don't think this the right approach. Plus, you still did not answer about optimizations. Maybe, currently, these attributes won't trigger dangerous optimizations but they can do this in the future and it may lead to unpredictable results. I would use the pessimistic model here rather than over-optimistic.

[jdoerfert]

This comment has been deleted.

clang/test/OpenMP/barrier_codegen.cpp

22

I did (try to) describe why there cannot be any problems wrt. optimizations:
The specified behavior of the runtime call is _as if_ it is readonly, nofree, and nosync.
That is, from the perspective of the compiler this is true and optimizations are allowed to use that fact.

The fact that the first ever runtime call initializes the runtime is neither part of the specification nor of the observable behavior. If we change the order between two call to __kmpc_global_thread_num, or similar calls, we cannot observe if/which one initialized the runtime and which read only stuff.

[ABataev]

clang/test/OpenMP/barrier_codegen.cpp

22

Here is the code of this function from the libomp:

  int gtid;

  if (!__kmp_init_serial) {
    gtid = KMP_GTID_DNE;
  } else
#ifdef KMP_TDATA_GTID
      if (TCR_4(__kmp_gtid_mode) >= 3) {
    KA_TRACE(1000, ("*** __kmp_get_global_thread_id_reg: using TDATA\n"));
    gtid = __kmp_gtid;
  } else
#endif
      if (TCR_4(__kmp_gtid_mode) >= 2) {
    KA_TRACE(1000, ("*** __kmp_get_global_thread_id_reg: using keyed TLS\n"));
    gtid = __kmp_gtid_get_specific();
  } else {
    KA_TRACE(1000,
             ("*** __kmp_get_global_thread_id_reg: using internal alg.\n"));
    gtid = __kmp_get_global_thread_id();
  }

  /* we must be a new uber master sibling thread */
  if (gtid == KMP_GTID_DNE) {
    KA_TRACE(10,
             ("__kmp_get_global_thread_id_reg: Encountered new root thread. "
              "Registering a new gtid.\n"));
    __kmp_acquire_bootstrap_lock(&__kmp_initz_lock);
    if (!__kmp_init_serial) {
      __kmp_do_serial_initialize();
      gtid = __kmp_gtid_get_specific();
    } else {
      gtid = __kmp_register_root(FALSE);
    }
    __kmp_release_bootstrap_lock(&__kmp_initz_lock);
    /*__kmp_printf( "+++ %d\n", gtid ); */ /* GROO */
  }

  KMP_DEBUG_ASSERT(gtid >= 0);

  return gtid;

As you can see, it is very complex. It has locks, in the debug mode it writes something, etc. It is not only about the initialization, there are some other calls (like __kmp_get_global_thread_id(), which really writes something). Do you really think it is safe to mark this as readonly and nosync?

[jdoerfert]

clang/test/OpenMP/barrier_codegen.cpp

22

Do you really think it is safe to mark this as readonly and nosync?

Yes. I am arguing why in the last few comments.

The central question is not what the function does but how it behaves (as long as we do not inline it, then what it does leaks).

[ABataev]

clang/test/OpenMP/barrier_codegen.cpp

22

I still don't think the right way to do it. Instead I would suggest to think about platform dependent attributes. Say, in general we use some pessimistic set of attributes but for some platforms (like NVPTX or AMDGCN) we can define more optimistic set of attributes.

[JonChesterfield]

clang/test/OpenMP/barrier_codegen.cpp

22

Properties that are true globally, in the as-if sense, but violated locally, if inlined, are a seriously complicated proposal. I don't want to block this patch on a satisfactory resolution to that so suggest we go with conservative.

[jdoerfert]

update test case

[ABataev]

LG

[jdoerfert]

Use IRBuilder for cancel barriers

[ABataev]

In D69922#1741659, @jdoerfert wrote:

Use IRBuilder for cancel barriers

In general, it would better to implement cancellation barriers in the separate patch. Same for OpenMPIrBuilder.

[jdoerfert]

Adjust paths and test case options

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3489

Also, you need to introduce/use RAII that saves/restores insertion point automatically.

3492

Maybe, instead of saving the state, pass the pointer to the cancel block as a parameter to the CreateBarrier function?

[kiranchandramohan]

Thanks @jdoerfert for working on this.

Sorry for being late to the party. I am trying to implement one trivial directive (Flush) and one slightly more involved (not decided).

I applied D69853, D69785, D69922 to my local build and found that D69922 is referring to OpenMPIRBuilder.h in llvm/Frontend whereas in D69785 it was introduced in llvm/Transforms/Utils/OpenMPIRBuilder.h

clang/lib/CodeGen/CGOpenMPRuntime.cpp

30

D69785 has this file in llvm/Transforms/Utils/OpenMPIRBuilder.h

clang/lib/CodeGen/CodeGenModule.cpp

55

D69785 has this file in llvm/Transforms/Utils/OpenMPIRBuilder.h

[jdoerfert]

In D69922#1742392, @ABataev wrote:

In D69922#1741659, @jdoerfert wrote:

Use IRBuilder for cancel barriers

In general, it would better to implement cancellation barriers in the separate patch. Same for OpenMPIrBuilder.

Why would you think that splitting these closely related concepts would be beneficial?

In D69922#1751827, @kiranchandramohan wrote:

Thanks @jdoerfert for working on this.

Sorry for being late to the party. I am trying to implement one trivial directive (Flush) and one slightly more involved (not decided).

I applied D69853, D69785, D69922 to my local build and found that D69922 is referring to OpenMPIRBuilder.h in llvm/Frontend whereas in D69785 it was introduced in llvm/Transforms/Utils/OpenMPIRBuilder.h

The conversation (on the llvm-dev list) seems to have settled on {include/llvm,lib}/frontend/OpenMP/. I will move the files around once we finally settle these reviews that haven't moved (more than 2 comments at a time).
As you can see, I have a huge backlog here and that is really hard to modify. You have a problem now as you depend on these. @hfinkel mentioned it in his email to the llvm-dev (about review etiquette), we need to
minimize iterations in reviews and actually review patches not only a few lines every time.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3492

All of this goes away in D70258, as it should. The frontend when creating a barrier does not need to know if it is cancelable and if so, where the cancel block is.

[jdoerfert]

rebase

[jdoerfert]

I applied D69853, D69785, D69922 to my local build and found that D69922 is referring to OpenMPIRBuilder.h in llvm/Frontend whereas in D69785 it was introduced in llvm/Transforms/Utils/OpenMPIRBuilder.h

I merged the first few patches. There are some I'm still waiting for the green light but the location question is now settled.

clang/include/clang/Driver/Options.td

1643–1644

I think people will need to use it in the short term, having it here seems therefor better.

clang/include/clang/Basic/LangOptions.def

 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(HIP               , 1, 0, "HIP")
 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
 LANGOPT(OpenMPSimd        , 1, 0, "Use SIMD only OpenMP support.")
 LANGOPT(OpenMPUseTLS      , 1, 0, "Use TLS for threadprivates or runtime calls")
 LANGOPT(OpenMPIsDevice    , 1, 0, "Generate code only for OpenMP target device")
 LANGOPT(OpenMPCUDAMode    , 1, 0, "Generate code for OpenMP pragmas in SIMT/SPMD mode")
+LANGOPT(OpenMPIRBuilder   , 1, 0, "Use the experimental OpenMP-IR-Builder codegen path.")
 LANGOPT(OpenMPCUDAForceFullRuntime , 1, 0, "Force to use full runtime in all constructs when offloading to CUDA devices")
 LANGOPT(OpenMPCUDANumSMs  , 32, 0, "Number of SMs for CUDA devices.")
 LANGOPT(OpenMPCUDABlocksPerSM  , 32, 0, "Number of blocks per SM for CUDA devices.")
 LANGOPT(OpenMPCUDAReductionBufNum , 32, 1024, "Number of the reduction records in the intermediate reduction buffer used for the teams reductions.")
 LANGOPT(OpenMPOptimisticCollapse  , 1, 0, "Use at most 32 bits to represent the collapsed loop nest counter.")
 LANGOPT(RenderScript      , 1, 0, "RenderScript")
 
 LANGOPT(CUDAIsDevice      , 1, 0, "compiling for CUDA device")

clang/include/clang/Driver/Options.td

 def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">, Flags<[DriverOption, CC1Option]>,
   HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">;
 def fopenmp_relocatable_target : Flag<["-"], "fopenmp-relocatable-target">,
   Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
 def fnoopenmp_relocatable_target : Flag<["-"], "fnoopenmp-relocatable-target">,
   Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
 def fopenmp_simd : Flag<["-"], "fopenmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
   HelpText<"Emit OpenMP code only for SIMD-based constructs.">;
+def fopenmp_enable_irbuilder : Flag<["-"], "fopenmp-enable-irbuilder">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>,
+  HelpText<"Use the experimental OpenMP-IR-Builder codegen path.">;
 def fno_openmp_simd : Flag<["-"], "fno-openmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fopenmp_cuda_mode : Flag<["-"], "fopenmp-cuda-mode">, Group<f_Group>,
   Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
 def fno_openmp_cuda_mode : Flag<["-"], "fno-openmp-cuda-mode">, Group<f_Group>,
   Flags<[NoArgumentUnused, HelpHidden]>;
 def fopenmp_cuda_force_full_runtime : Flag<["-"], "fopenmp-cuda-force-full-runtime">, Group<f_Group>,
   Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
 def fno_openmp_cuda_force_full_runtime : Flag<["-"], "fno-openmp-cuda-force-full-runtime">, Group<f_Group>,

clang/lib/CodeGen/CGOpenMPRuntime.cpp

 #include "clang/CodeGen/ConstantInitBuilder.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/Basic/BitmaskEnum.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/OpenMPIRBuilder.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 
 using namespace clang;
 using namespace CodeGen;
 using namespace llvm::omp;
 
 namespace {
 /// Base class for handling code generation inside OpenMP regions.
 class CGOpenMPRegionInfo : public CodeGenFunction::CGCapturedStmtInfo {
ChunkExpr = IntegerLiteral::Create(
         CGF.getContext().getIntTypeForBitwidth(32, /*Signed=*/0),
         SourceLocation());
   }
 }
 
 void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
                                       OpenMPDirectiveKind Kind, bool EmitChecks,
                                       bool ForceSimpleCall) {
+  // Check if we can use the OMPBuilder
+  // TODO: Implement missing functionality and remove this check and directly
+  //       invoke the builder without going through the CGOpenMPRuntime.
+  auto *OMPRegionInfo =
+      dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo);
+  llvm::OpenMPIRBuilder *OMPBuilder = CGF.CGM.getOpenMPIRBuilder();
+  if (OMPBuilder && (!EmitChecks || ForceSimpleCall || !OMPRegionInfo ||
+                     !OMPRegionInfo->hasCancel())) {
+    OMPBuilder->CreateBarrier({CGF.Builder.saveIP()}, Kind, ForceSimpleCall,
+                              EmitChecks);
+    return;
+  }
+
   if (!CGF.HaveInsertPoint())
     return;
   // Build call __kmpc_cancel_barrier(loc, thread_id);
   // Build call __kmpc_barrier(loc, thread_id);
   unsigned Flags = getDefaultFlagsForBarriers(Kind);
   // Build call __kmpc_cancel_barrier(loc, thread_id) or __kmpc_barrier(loc,
   // thread_id);
   llvm::Value *Args[] = {emitUpdateLocation(CGF, Loc, Flags),
                          getThreadID(CGF, Loc)};
-  if (auto *OMPRegionInfo =
-          dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo)) {
+  if (OMPRegionInfo) {
     if (!ForceSimpleCall && OMPRegionInfo->hasCancel()) {
       llvm::Value *Result = CGF.EmitRuntimeCall(
           createRuntimeFunction(OMPRTL__kmpc_cancel_barrier), Args);
       if (EmitChecks) {
         // if (__kmpc_cancel_barrier()) {
         //   exit from construct;
         // }
         llvm::BasicBlock *ExitBB = CGF.createBasicBlock(".cancel.exit");

clang/lib/CodeGen/CodeGenModule.h

 class Module;
 class Constant;
 class ConstantInt;
 class Function;
 class GlobalValue;
 class DataLayout;
 class FunctionType;
 class LLVMContext;
+class OpenMPIRBuilder;
 class IndexedInstrProfReader;
 }
 
 namespace clang {
 class ASTContext;
 class AtomicType;
 class FunctionDecl;
 class IdentifierInfo;
private:
   CodeGenTypes Types;
 
   /// Holds information about C++ vtables.
   CodeGenVTables VTables;
 
   std::unique_ptr<CGObjCRuntime> ObjCRuntime;
   std::unique_ptr<CGOpenCLRuntime> OpenCLRuntime;
   std::unique_ptr<CGOpenMPRuntime> OpenMPRuntime;
+  std::unique_ptr<llvm::OpenMPIRBuilder> OMPBuilder;
   std::unique_ptr<CGCUDARuntime> CUDARuntime;
   std::unique_ptr<CGDebugInfo> DebugInfo;
   std::unique_ptr<ObjCEntrypoints> ObjCData;
   llvm::MDNode *NoObjCARCExceptionsMetadata = nullptr;
   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
   InstrProfStats PGOStats;
   std::unique_ptr<llvm::SanitizerStatReport> SanStats;
 
public:
   }
 
   /// Return a reference to the configured OpenMP runtime.
   CGOpenMPRuntime &getOpenMPRuntime() {
     assert(OpenMPRuntime != nullptr);
     return *OpenMPRuntime;
   }
 
+  /// Return a pointer to the configured OpenMPIRBuilder, if any.
+  llvm::OpenMPIRBuilder *getOpenMPIRBuilder() { return OMPBuilder.get(); }
+
   /// Return a reference to the configured CUDA runtime.
   CGCUDARuntime &getCUDARuntime() {
     assert(CUDARuntime != nullptr);
     return *CUDARuntime;
   }
 
   ObjCEntrypoints &getObjCEntrypoints() const {
     assert(ObjCData != nullptr);

clang/lib/CodeGen/CodeGenModule.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/OpenMPIRBuilder.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/TimeProfiler.h"
 
case llvm::Triple::nvptx64:
     break;
   default:
     if (LangOpts.OpenMPSimd)
       OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
     else
       OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
     break;
   }
+
+  // The OpenMP-IR-Builder should eventually replace the above runtime codegens
+  // but we are not there yet so they both reside in CGModule for now and the
+  // OpenMP-IR-Builder is opt-in only.
+  if (LangOpts.OpenMPIRBuilder) {
+    OMPBuilder.reset(new llvm::OpenMPIRBuilder(TheModule));
+    OMPBuilder->initialize();
+  }
 }
 
 void CodeGenModule::createCUDARuntime() {
   CUDARuntime.reset(CreateNVCUDARuntime(*this));
 }
 
 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
   Replacements[Name] = C;

clang/lib/Driver/ToolChains/Clang.cpp

case Driver::OMPRT_IOMP5:
       // If no option regarding the use of TLS in OpenMP codegeneration is
       // given, decide a default based on the target. Otherwise rely on the
       // options and pass the right information to the frontend.
       if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
                         options::OPT_fnoopenmp_use_tls, /*Default=*/true))
         CmdArgs.push_back("-fnoopenmp-use-tls");
       Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
                       options::OPT_fno_openmp_simd);
+      Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
       Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
       Args.AddAllArgs(CmdArgs,
                       options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
       if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
                        options::OPT_fno_openmp_optimistic_collapse,
                        /*Default=*/false))

clang/lib/Frontend/CompilerInvocation.cpp

#include "clang/Basic/LangStandards.def"
   bool IsSimdSpecified =
       Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
                    /*Default=*/false);
   Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
   Opts.OpenMPUseTLS =
       Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
   Opts.OpenMPIsDevice =
       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
+  Opts.OpenMPIRBuilder =
+      Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
   bool IsTargetSpecified =
       Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
 
   if (Opts.OpenMP || Opts.OpenMPSimd) {
     if (int Version = getLastArgIntValue(
             Args, OPT_fopenmp_version_EQ,
             (IsSimdSpecified || IsTargetSpecified) ? 45 : Opts.OpenMP, Diags))
       Opts.OpenMP = Version;

clang/test/Driver/fopenmp.c

 // CHECK-LD-STATIC-IOMP5: "{{.*}}ld{{(.exe)?}}"
 // CHECK-LD-STATIC-IOMP5: "-Bstatic" "-liomp5" "-Bdynamic"
 //
 // CHECK-LD-STATIC-IOMP5-NO-BDYNAMIC: "{{.*}}ld{{(.exe)?}}"
 // For x86 Gnu, the driver passes -static, while NetBSD and FreeBSD pass -Bstatic
 // CHECK-LD-STATIC-IOMP5-NO-BDYNAMIC: "-{{B?}}static" {{.*}} "-liomp5"
 // CHECK-LD-STATIC-IOMP5-NO-BDYNAMIC-NOT: "-Bdynamic"
 //
+// RUN: %clang -target x86_64-linux-gnu -fopenmp -fopenmp-enable-irbuilder -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CC1-OPENMPIRBUILDER
+//
+// CHECK-CC1-OPENMPIRBUILDER: "-cc1"
+// CHECK-CC1-OPENMPIRBUILDER: "-fopenmp"
+// CHECK-CC1-OPENMPIRBUILDER: "-fopenmp-enable-irbuilder"
+//
 // We'd like to check that the default is sane, but until we have the ability
 // to *always* semantically analyze OpenMP without always generating runtime
 // calls (in the event of an unsupported runtime), we don't have a good way to
 // test the CC1 invocation. Instead, just ensure we do eventually link *some*
 // OpenMP runtime.
 //
 // RUN: %clang -target x86_64-linux-gnu -fopenmp %s -o %t -### 2>&1 | FileCheck %s --check-prefix=CHECK-LD-ANY
 // RUN: %clang -target x86_64-darwin -fopenmp %s -o %t -### 2>&1 | FileCheck %s --check-prefix=CHECK-LD-ANY

clang/test/OpenMP/barrier_codegen.cpp

-// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CLANGCG
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-pch -o %t %s
-// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CLANGCG
+
+// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -fopenmp-enable-irbuilder -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,IRBUILDER
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fopenmp-enable-irbuilder -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fopenmp-enable-irbuilder -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,IRBUILDER
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
 // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER
 
 // CHECK: [[IDENT_T:%.+]] = type { i32, i32, i32, i32, i8* }
 // CHECK-DAG: [[EXPLICIT_BARRIER_LOC:@.+]] = {{.+}} [[IDENT_T]] { i32 0, i32 34, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]+}} x i8], [{{[0-9]+}} x i8]* @{{.+}}, i32 0, i32 0) }
 // CHECK-DAG: [[LOC:@.+]] = {{.+}} [[IDENT_T]] { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]+}} x i8], [{{[0-9]+}} x i8]* @{{.+}}, i32 0, i32 0) }
 
 void foo() {}
 
 template <class T>
 T tmain(T argc) {
   static T a;
 #pragma omp barrier
   return a + argc;
 }
 
 // CHECK-LABEL: @main
 int main(int argc, char **argv) {
   static int a;
 #pragma omp barrier
   // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]])
   // CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]])
   // CHECK: call {{.+}} [[TMAIN_INT:@.+]](i{{[0-9][0-9]}}
   // CHECK: call {{.+}} [[TMAIN_CHAR:@.+]](i{{[0-9]}}
   return tmain(argc) + tmain(argv[0][0]) + a;
 }
 
+// CLANGCG-NOT: inaccessiblemem
+// IRBUILDER:      ; Function Attrs: inaccessiblemem_or_argmemonly nofree nosync nounwind readonly
+// IRBUILDER-NEXT: declare i32 @__kmpc_global_thread_num(%struct.ident_t*)
+
 // CHECK: define {{.+}} [[TMAIN_INT]](
 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]])
 // CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]])
 
 // CHECK: define {{.+}} [[TMAIN_CHAR]](
 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]])
 // CHECK: call void @__kmpc_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]])
 
 #endif