[RFC][Flang][OMPIRBuilder] Add nounwind attribute to the LLVM IR

[domada]

Summary

Check if generated code can be marked as the code which does not throw an exception.

If LLVM IR does not throw an exception, add nounwind function attribute.

This patch depends on https://reviews.llvm.org/D147313

[domada]

Patch rebased

[jdoerfert]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

5063

Style F

5063

Why does this belong here? We should do it like clang, one function at a time, or in a generic place. This is not OpenMP specific at all.

llvm/lib/IR/IRBuilder.cpp

1426

No llvm::

[domada]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

5063

Hi Johannes,
thank you very much for your feedback.

I would like to explain my idea why I add this function to OMPIRBuilder:

Current situation:

1. MLIR does not support LLVM IR function attributes for production quality code. MLIR function passthrough attributes should be used only for PoC work ( https://mlir.llvm.org/docs/Dialects/LLVM/#attribute-pass-through )
2. OpenMP MLIR operations can be translated into multiple LLVM IR functions.

My idea was to add functionality of inserting function attributes after the end of OpenMP MLIR code translation. OMPIRBuilder has necessary knowledge about generated LLVM IR. That's why I decided to do it here and to focus mainly on the code generated for OpenMP pragmas.

clang/lib/CodeGen/CodeGenFunction.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/FPEnv.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/CRC.h"
 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
 #include <optional>
void CodeGenFunction::EmitBlockWithFallThrough(llvm::BasicBlock *BB,
   EmitBlock(BB);
   uint64_t CurrentCount = getCurrentProfileCount();
   incrementProfileCounter(S);
   setCurrentProfileCount(getCurrentProfileCount() + CurrentCount);
   if (SkipCountBB)
     EmitBlock(SkipCountBB);
 }
 
-/// Tries to mark the given function nounwind based on the
-/// non-existence of any throwing calls within it.  We believe this is
-/// lightweight enough to do at -O0.
-static void TryMarkNoThrow(llvm::Function *F) {
-  // LLVM treats 'nounwind' on a function as part of the type, so we
-  // can't do this on functions that can be overwritten.
-  if (F->isInterposable()) return;
-
-  for (llvm::BasicBlock &BB : *F)
-    for (llvm::Instruction &I : BB)
-      if (I.mayThrow())
-        return;
-
-  F->setDoesNotThrow();
-}
-
 QualType CodeGenFunction::BuildFunctionArgList(GlobalDecl GD,
                                                FunctionArgList &Args) {
   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
   QualType ResTy = FD->getReturnType();
 
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
   if (MD && MD->isInstance()) {
     if (CGM.getCXXABI().HasThisReturn(GD))
void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
   }
 
   // Emit the standard function epilogue.
   FinishFunction(BodyRange.getEnd());
 
   // If we haven't marked the function nothrow through other means, do
   // a quick pass now to see if we can.
   if (!CurFn->doesNotThrow())
-    TryMarkNoThrow(CurFn);
+    llvm::IRBuilderBase::TryMarkNoThrow(CurFn);
 }
 
 /// ContainsLabel - Return true if the statement contains a label in it.  If
 /// this statement is not executed normally, it not containing a label means
 /// that we can just remove the code.
 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
   // Null statement, not a label!
   if (!S) return false;

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

GlobalVariable *getOrCreateInternalVariable(Type *Ty, const StringRef &Name,
                                               unsigned AddressSpace = 0);
 
   /// Add function attribute to all functions which are defined inside module
   /// but they don't have given attribute
   /// \param AttributeName Name of the attribute
   /// \param AttributeValue Value of the attribute
   void addAttributeToModuleFunctions(StringRef AttributeName,
                                      StringRef AttributeValue);
+
+  /// Try to add nounwind attribute to the generated functions
+  void tryMarkNoThrowModuleFunctions();
 };
 
 /// Class to represented the control flow structure of an OpenMP canonical loop.
 ///
 /// The control-flow structure is standardized for easy consumption by
 /// directives associated with loops. For instance, the worksharing-loop
 /// construct may change this control flow such that each loop iteration is
 /// executed on only one thread. The constraints of a canonical loop in brief

llvm/include/llvm/IR/IRBuilder.h

public:
   /// must be subtracted from the provided pointer to get the pointer with the
   /// specified alignment.
   ///
   /// This overload handles the condition where the Alignment is dependent
   /// on an existing value rather than a static value.
   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
                                       Value *Alignment,
                                       Value *OffsetValue = nullptr);
+
+  /// Tries to mark the given function nounwind based on the
+  /// non-existence of any throwing calls within it.  We believe this is
+  /// lightweight enough to do at -O0.
+  static void TryMarkNoThrow(llvm::Function *F);
 };
 
 /// This provides a uniform API for creating instructions and inserting
 /// them into a basic block: either at the end of a BasicBlock, or at a specific
 /// iterator location in a block.
 ///
 /// Note that the builder does not expose the full generality of LLVM
 /// instructions.  For access to extra instruction properties, use the mutators

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

for (Function &f : M.functions()) {
     if (f.isDeclaration())
       continue;
     if (f.hasFnAttribute(AttributeName))
       continue;
     f.addFnAttr(AttributeName, AttributeValue);
   }
 }
 
+void OpenMPIRBuilder::tryMarkNoThrowModuleFunctions() {
+  for (Function &f : M.functions()) {
+    if (f.isDeclaration())
+      continue;
+    if (f.hasFnAttribute(Attribute::NoUnwind))
+      continue;
+    IRBuilderBase::TryMarkNoThrow(&f);
+  }
+}
+
 void TargetRegionEntryInfo::getTargetRegionEntryFnName(
     SmallVectorImpl<char> &Name, StringRef ParentName, unsigned DeviceID,
     unsigned FileID, unsigned Line, unsigned Count) {
   raw_svector_ostream OS(Name);
   OS << "__omp_offloading" << llvm::format("_%x", DeviceID)
      << llvm::format("_%x_", FileID) << ParentName << "_l" << Line;
   if (Count)
     OS << "_" << Count;

llvm/lib/IR/IRBuilder.cpp

CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL,
                                                    Value *PtrValue,
                                                    Value *Alignment,
                                                    Value *OffsetValue) {
   assert(isa<PointerType>(PtrValue->getType()) &&
          "trying to create an alignment assumption on a non-pointer?");
   return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue);
 }
 
+void IRBuilderBase::TryMarkNoThrow(llvm::Function *F) {
+  // LLVM treats 'nounwind' on a function as part of the type, so we
+  // can't do this on functions that can be overwritten.
+  if (F->isInterposable())
+    return;
+
+  for (llvm::BasicBlock &BB : *F)
+    for (llvm::Instruction &I : BB)
+      if (I.mayThrow())
+        return;
+
+  F->setDoesNotThrow();
+}
+
 IRBuilderDefaultInserter::~IRBuilderDefaultInserter() = default;
 IRBuilderCallbackInserter::~IRBuilderCallbackInserter() = default;
 IRBuilderFolder::~IRBuilderFolder() = default;
 void ConstantFolder::anchor() {}
 void NoFolder::anchor() {}

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

 } // namespace
 
 /// Given an OpenMP MLIR attribute, create the corresponding LLVM-IR, runtime
 /// calls, or operation amendments
 LogicalResult OpenMPDialectLLVMIRTranslationInterface::amendOperation(
     Operation *op, NamedAttribute attribute,
     LLVM::ModuleTranslation &moduleTranslation) const {
 
+  llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
+  ompBuilder->tryMarkNoThrowModuleFunctions();
+
   return llvm::TypeSwitch<Attribute, LogicalResult>(attribute.getValue())
       .Case([&](mlir::omp::FlagsAttr rtlAttr) {
         return convertFlagsAttr(op, rtlAttr, moduleTranslation);
       })
       .Case([&](omp::TargetAttr targetAttr) {
         return setLLVMFunctionTargetAttr(op, targetAttr, moduleTranslation);
       })
       .Default([&](Attribute attr) {

mlir/test/Target/LLVMIR/openmp-llvm.mlir

 
 // CHECK: @omp_target_features_test() #0 {
 module attributes {llvm.target_triple = "amdgcn-amd-amdhsa", omp.target = #omp.target<target_cpu = "gfx908", target_features = "+dot3-insts,+dot4-insts,+s-memtime-inst,+16-bit-insts,+s-memrealtime,+dot6-insts,+dl-insts,+wavefrontsize64,+gfx9-insts,+gfx8-insts,+ci-insts,+dot10-insts,+dot7-insts,+dot1-insts,+dot5-insts,+mai-insts,+dpp,+dot2-insts">} {
   llvm.func @omp_target_features_test() {
     llvm.return
   }
 }
 
-// CHECK: attributes #0 = { "target-cpu"="gfx908"
+// CHECK: attributes #0 = { nounwind "target-cpu"="gfx908"
 // CHECK-SAME: "target-features"="+dot3-insts,+dot4-insts,+s-memtime-inst,
 // CHECK-SAME: +16-bit-insts,+s-memrealtime,+dot6-insts,+dl-insts,
 // CHECK-SAME: +wavefrontsize64,+gfx9-insts,+gfx8-insts,+ci-insts,+dot10-insts,
 // CHECK-SAME: +dot7-insts,+dot1-insts,+dot5-insts,+mai-insts,+dpp,+dot2-insts"
 
 // -----
 
 module attributes {llvm.target_triple = "amdgcn-amd-amdhsa",  omp.target = #omp.target<target_cpu = "gfx908", target_features = "+dot3-insts,+dot4-insts,+s-memtime-inst,+16-bit-insts,+s-memrealtime,+dot6-insts,+dl-insts,+wavefrontsize64,+gfx9-insts,+gfx8-insts,+ci-insts,+dot10-insts,+dot7-insts,+dot1-insts,+dot5-insts,+mai-insts,+dpp,+dot2-insts">} {
 // CHECK: @test_omp_attr() #0 {
 // CHECK: @test_omp_attr..omp_par() #0 {
 // CHECK: @test_omp_attr..omp_par.wrapper(i32 %{{.*}}) #0 {
 
   llvm.func @test_omp_attr() {
     omp.task {
       omp.terminator
     }
   llvm.return
   }
 }
-// CHECK: attributes #0 = { "target-cpu"="gfx908"
+// CHECK: attributes #0 = {  nounwind "target-cpu"="gfx908"
 // CHECK-SAME: "target-features"="+dot3-insts,+dot4-insts,+s-memtime-inst,
 // CHECK-SAME: +16-bit-insts,+s-memrealtime,+dot6-insts,+dl-insts,
 // CHECK-SAME: +wavefrontsize64,+gfx9-insts,+gfx8-insts,+ci-insts,+dot10-insts,
 // CHECK-SAME: +dot7-insts,+dot1-insts,+dot5-insts,+mai-insts,+dpp,+dot2-insts"