Adding Flush support in OpenMPIRBuilder

[kiranchandramohan]

Summary

This patch adds support for the Flush construct in the OpenMPIRBuilder introduced in D69785. The change is closely based on D69828.

[jdoerfert]

Minor comments and overall fine approach. Could you update the test so I can accept it? Later I will assume changes like this are made before it is commited.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3877

You can even move the code to the beginning of the function (see my comment below as well).

Nit: I personally prefer conditionals to have braces in all parts or no braces at all. I get itchy when we have a branch with and one without.

llvm/include/llvm/Transforms/Utils/OpenMPIRBuilder.h

81

I think we settled on CreateXXX as naming scheme to match the IRBuilder for now.

llvm/lib/Frontend/OpenMPIRBuilder.cpp

250

Can you adopt the scheme below (w/o assert for now)

if (!updateToLocation(Loc))
   return;

I'm not certain why we support an "invalid" insertion point but the update method also sets the debug information properly.

[jdoerfert]

One more thing, I would not call this NFC, nor WIP for that matter (in the commit message).

[jdoerfert]

@fghanim created a spreadsheet so we can coordinate our porting efforts:

https://docs.google.com/spreadsheets/d/1FvHPuSkGbl4mQZRAwCIndvQx9dQboffiD-xD0oqxgU0/edit?usp=sharing

please feel free to add directives there you intent to port.

[kiranchandramohan]

Addressed review comments.

1. Adding a test
2. Change emitFlush to CreateFlush in OpenMPIRBuilder.cpp
3. Use updateLoc
4. Fixed formatting

[jdoerfert]

LGTM.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::emitProcBindClause(CodeGenFunction &CGF,
   llvm::Value *Args[] = {
       emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc),
       llvm::ConstantInt::get(CGM.IntTy, RuntimeProcBind, /*isSigned=*/true)};
   CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_push_proc_bind), Args);
 }
 
 void CGOpenMPRuntime::emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *>,
                                 SourceLocation Loc) {
+  llvm::OpenMPIRBuilder *OMPBuilder = CGF.CGM.getOpenMPIRBuilder();
+  if (OMPBuilder) {
+    OMPBuilder->CreateFlush(CGF.Builder);
+  } else {
     if (!CGF.HaveInsertPoint())
       return;
     // Build call void __kmpc_flush(ident_t *loc)
     CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_flush),
                         emitUpdateLocation(CGF, Loc));
   }
+}
 
 namespace {
 /// Indexes of fields for type kmp_task_t.
 enum KmpTaskTFields {
   /// List of shared variables.
   KmpTaskTShareds,
   /// Task routine.
   KmpTaskTRoutine,

clang/test/OpenMP/flush_codegen.cpp

 // RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-enable-irbuilder -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -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

llvm/include/llvm/Frontend/OpenMPKinds.def

 #define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...)
 #endif
 
 #define __OMP_RTL(Name, IsVarArg, ReturnType, ...)                             \
   OMP_RTL(OMPRTL_##Name, #Name, IsVarArg, ReturnType, __VA_ARGS__)
 
 __OMP_RTL(__kmpc_barrier, false, Void, IdentPtr, Int32)
 __OMP_RTL(__kmpc_cancel_barrier, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_flush, false, Void, IdentPtr)
 __OMP_RTL(__kmpc_global_thread_num, false, Int32, IdentPtr)
 __OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr)
 __OMP_RTL(omp_get_thread_num, false, Int32, )
 
 #undef __OMP_RTL
 #undef OMP_RTL
 
 #define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind)

llvm/include/llvm/Transforms/Utils/OpenMPIRBuilder.h

public:
   ///
   /// \returns The insertion point after the barrier.
   InsertPointTy CreateBarrier(const LocationDescription &Loc, omp::Directive DK,
                               bool ForceSimpleCall = false,
                               bool CheckCancelFlag = true);
 
   ///}
 
+  /// Generator for '#omp flush'
+  ///
+  /// \param Loc The location where the flush directive was encountered
+  void CreateFlush(const LocationDescription &Loc);
+
+
 private:
   /// Update the internal location to \p Loc.
   bool updateToLocation(const LocationDescription &Loc) {
     Builder.restoreIP(Loc.IP);
     Builder.SetCurrentDebugLocation(Loc.DL);
     return Loc.IP.getBlock() != nullptr;
   }
 
private:
   /// \param CheckCancelFlag Flag to indicate a cancel barrier return value
   ///                        should be checked and acted upon.
   ///
   /// \returns The insertion point after the barrier.
   InsertPointTy emitBarrierImpl(const LocationDescription &Loc,
                                 omp::Directive DK, bool ForceSimpleCall,
                                 bool CheckCancelFlag);
 
+  /// Generate a flush runtime call.
+  ///
+  /// \param Loc The location at which the request originated and is fulfilled.
+  void emitFlush(const LocationDescription &Loc);
+
   /// Return the current thread ID.
   ///
   /// \param Ident The ident (ident_t*) describing the query origin.
   Value *getOrCreateThreadID(Value *Ident);
 
   /// The underlying LLVM-IR module
   Module &M;
 

llvm/lib/Frontend/OpenMPIRBuilder.cpp

BasicBlock *ContinuationBB = BasicBlock::Create(
         BB->getContext(), BB->getName() + ".cont", BB->getParent());
     Builder.CreateCondBr(Cmp, ContinuationBB, CancellationBlock,
                          /* TODO weight */ nullptr, nullptr);
     Builder.SetInsertPoint(ContinuationBB);
   }
 
   return Builder.saveIP();
 }
+
+void OpenMPIRBuilder::emitFlush(const LocationDescription &Loc)
+{
+  // Build call void __kmpc_flush(ident_t *loc)
+  Constant *SrcLocStr = getOrCreateSrcLocStr(Loc);
+  Value *Args[] = {getOrCreateIdent(SrcLocStr)};
+
+  Builder.CreateCall(getOrCreateRuntimeFunction(OMPRTL___kmpc_flush), Args);
+}
+
+void OpenMPIRBuilder::CreateFlush(const LocationDescription &Loc)
+{
+  if (!updateToLocation(Loc))
+   return;
+  emitFlush(Loc);
+}