Add OpenMP for optimization

[abidmalikwaterloo]

Summary

Adding test cases

Update OpenMPOpt.cpp

Make cahnges in OpenMPOpt.cpp

[jdoerfert]

Adding test cases

There are still no test cases.

[abidmalikwaterloo]

In D90103#2352442, @jdoerfert wrote:

Adding test cases

There are still no test cases.

Yes. I have tests. I will add it to the LIT and will update the patch.

[jdoerfert]

reverse ping. Also, I left comments in the original review that have not been addressed.

[abidmalikwaterloo]

In D90103#2352453, @abidmalikwaterloo wrote:

In D90103#2352442, @jdoerfert wrote:

Adding test cases

There are still no test cases.

Yes. I have tests. I will add it to the LIT and will update the patch.

Previous patch:

https://reviews.llvm.org/D75384

[sstefan1]

On the first look, you should at least clang-format this as it is not very readable right now.

There are still no tests.

.arcconfig

4

This seems unrelated.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

70

Maybe consider using LLVM's ADTs.? Same goes for the rest of the patch.

Also, you should follow the coding style

411

Seems unused.

[abidmalikwaterloo]

• make changes in OpenMPOpt

[abidmalikwaterloo]

This comment was removed by abidmalikwaterloo.

.arcconfig

4

Should I then include the following?

"repository.callsign" : "G",
"conduit_uri" : "https://reviews.llvm.org/"

[abidmalikwaterloo]

The tests should be in llvm-project/llvm/test/Transforms/OpenMP.

[sstefan1]

In D90103#2410284, @abidmalikwaterloo wrote:

The tests should be in llvm-project/llvm/test/Transforms/OpenMP.

Yes, no need for new folder.

.arcconfig

4

I'm saying I don't see the reason for this to be in the patch.

[abidmalikwaterloo]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

70

Can you elaborate? std::map is llvm ADT.
https://llvm.org/docs/ProgrammersManual.html#map

[sstefan1]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

70

SmallVector, DenseMap for example, see https://llvm.org/docs/ProgrammersManual.html#dss-densemap

[abidmalikwaterloo]

• added test case for parallel openmp for loop merging

[abidmalikwaterloo]

added a test. Would like to have feedback to add more.

[abidmalikwaterloo]

Added a test for OpenMP for loop fusion. Is the sample test acceptable? I can add more in the same format.

[abidmalikwaterloo]

• Added a test case for OMP loop for merging

[jdoerfert]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

70

std:: is from the C++ standard library. The programmers manual specifies the pros and cons and usually ADT implementations are preferable.

llvm/test/Transforms/OpenMP/parallelMergeForLoop.ll

909 ↗

(On Diff #313643)

I kind of doubt this test passes given that the functions are marked optnone. Did you run the tests and confirmed they pass?

llvm/test/Transforms/OpenMP/parallel_for_loop_merging.cpp

38 ↗

(On Diff #313643)

How can this test pass without running optimizations, not that we actually want to run a C++ test here anyway.

[jdoerfert]

The optimization code is lacking in various regards. Let's focus on addressing the test remarks first in order to upstream those. We can revisit how to proceed with the optimization code after, e.g., revisit the algorithm from scratch.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

198

This has not bee rebased for moths, all clang generated functions should be in here by now.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

82

LLVM style, e.g., naming conventions, still not adapted.
Various members are unsued, others seem to track information already present in the IR/CFG unmodifed.

407

This code is basically impossible to review.

• The coding style is not LLVMs and the code is not properly formatted.
• There is no comment explaining what is going on and why.
• The functions have generic names unrelated to the specific functionality.
• The number of data structures, e.g., maps and vectors, seems excessive. While their usage remains unclear it seems the approach so far "analyzes" the code first and builds up a record before taking action. It is often preferable to pick a runtime call, determine if it can be removed, do it if possible, and go to the next. Furthermore, mappings that are already available elsewhere should not be build.

[abidmalikwaterloo]

I have a new patch that I wrote with LLVM-11 .0. The current patchwork is based on LLVM-9.0. The OpenMPOpt.CPP has a lot of modifications. What is the best way to submit the new patch? Any suggestion would be helpful.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

198

LLVM 11 OMPKinds.def has all the RTL call which makes this update redundent.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

82

In the new patch which is based on LLVM 11 update, I took care of this for simple cases that do not include a control statement. The new patch is very small as compare to this one and used LLVM data structures for MAP and Vectors.

407

Hopefully, this will be taken care of by the new patch

llvm/test/Transforms/OpenMP/parallelMergeForLoop.ll

909 ↗

(On Diff #313643)

"optnone" is part of the comments when I compile the test without any optimizations. My understanding is that the IR should be without any optimization. The c code tests are running perfectly and I am getting IR what it should be. However, when I used the IR as input some parts of the tests especially related to condition are breaking. I compacted the new patch which is small ( about 150 lines) and in line with the LLVM software requirement. I am testing it and will upload it after cleaning it.

909 ↗

(On Diff #313643)

I included four tests that take care of most cases except the nested control statements.

llvm/test/Transforms/OpenMP/parallel_for_loop_merging.cpp

38 ↗

(On Diff #313643)

Yes.. optimization should be there. It is a redundant test as the test should be in IR format. I will remove it when I upload the new work. However, this test work with the patch.

[abidmalikwaterloo]

In D90103#2532459, @jdoerfert wrote:

The optimization code is lacking in various regards. Let's focus on addressing the test remarks first in order to upstream those. We can revisit how to proceed with the optimization code after, e.g., revisit the algorithm from scratch.

I would like to submit the tests along with the new patch. Some tests are failing with this patch. Or should I just submit all possible tests first ( whether the patch successfully runs or not)?

[abidmalikwaterloo]

1. rewrote the patch and elimate lot of redundent stuff
   • Added a test case for OMP loop for merging

[abidmalikwaterloo]

uploaded a new patch which is short and works on the cases without conditional statements

[abidmalikwaterloo]

Should I upload all potential tests in C/C++ format to define the scope of this patch? We can convert it to IR format later for upstreaming.

[jdoerfert]

Let's focus on the tests without the optimization code.

On that front:

1. Avoid unnecessary complexity, i.a., print, and go for simple identifiable calls, like body1()
2. Remove everything from the test that is not needed, e.g. unrelated functions, attributes, etc.
3. Preprocess the tests with common passes such as mem2reg, instcombine, and simplifycfg. We only want to run openmpopt on them later, never O3.

[abidmalikwaterloo]

In D90103#2549979, @jdoerfert wrote:

Let's focus on the tests without the optimization code.

On that front:

1. Avoid unnecessary complexity, i.a., print, and go for simple identifiable calls, like body1()
2. Remove everything from the test that is not needed, e.g. unrelated functions, attributes, etc.
3. Preprocess the tests with common passes such as mem2reg, instcombine, and simplifycfg. We only want to run openmpopt on them later, never O3.

Is there a set of other common passes that are required for this level of testing? Could not figure out from the other OpenMP IR test cases.

[abidmalikwaterloo]

• A modified parallel_omp_for_loop_merge1.ll is added . Taking care of the comments

[jdoerfert]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

138

Why would we unpack the arguments if we can look them up in a call?

237

Let's create a revision just with the test first. The code above will require rewriting and reviewing is hard, partially because of formatting and naming conventions. FWIW, OpenMPOpt is clang-formatted.

llvm/test/Transforms/OpenMP/parallel_omp_for_loop_merge1.ll

2

can you run the update_test_checks.py script on this to create the run lines.

[abidmalikwaterloo]

• Apply the update_test_checks.py

[abidmalikwaterloo]

x - Clean the code

• clean the code

[abidmalikwaterloo]

In D90103#2622092, @abidmalikwaterloo wrote:

• Apply the update_test_checks.py

I have cleaned it

llvm/test/Transforms/OpenMP/parallel_omp_for_loop_merge1.ll

2

can you run the update_test_checks.py script on this to create the run lines.

Done

.arcconfig

 {
-  "phabricator.uri" : "https://reviews.llvm.org/",
+
   "repository.callsign" : "G",
   "conduit_uri" : "https://reviews.llvm.org/"
 }

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

 __OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr)
 __OMP_RTL(__kmpc_omp_taskwait, false, Int32, IdentPtr, Int32)
 __OMP_RTL(__kmpc_omp_taskyield, false, Int32, IdentPtr, Int32, Int32)
 __OMP_RTL(__kmpc_push_num_threads, false, Void, IdentPtr, Int32,
           /* Int */ Int32)
 __OMP_RTL(__kmpc_push_proc_bind, false, Void, IdentPtr, Int32, /* Int */ Int32)
 __OMP_RTL(__kmpc_serialized_parallel, false, Void, IdentPtr, Int32)
 __OMP_RTL(__kmpc_end_serialized_parallel, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_for_static_init_4, false, Void, IdentPtr, Int32, Int32, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32 )
+__OMP_RTL(__kmpc_for_static_fini, false, Void, IdentPtr, Int32)
 
 __OMP_RTL(omp_get_thread_num, false, Int32, )
 __OMP_RTL(omp_get_num_threads, false, Int32, )
 __OMP_RTL(omp_get_max_threads, false, Int32, )
 __OMP_RTL(omp_in_parallel, false, Int32, )
 __OMP_RTL(omp_get_dynamic, false, Int32, )
 __OMP_RTL(omp_get_cancellation, false, Int32, )
 __OMP_RTL(omp_get_nested, false, Int32, )

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

 //===-- IPO/OpenMPOpt.cpp - Collection of OpenMP specific optimizations ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // OpenMP specific optimizations:
 //
 // - Deduplication of runtime calls, e.g., omp_get_thread_num.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/OpenMPOpt.h"
-
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/EnumeratedArray.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/CallGraphUpdater.h"
+#include <algorithm>
 
 using namespace llvm;
 using namespace omp;
 using namespace types;
 
 #define DEBUG_TYPE "openmp-opt"
 
 static cl::opt<bool> DisableOpenMPOptimizations(
OpenMPOpt(SmallPtrSetImpl<Function *> &SCC,
             SmallPtrSetImpl<Function *> &ModuleSlice,
             CallGraphUpdater &CGUpdater)
       : M(*(*SCC.begin())->getParent()), SCC(SCC), ModuleSlice(ModuleSlice),
         OMPBuilder(M), CGUpdater(CGUpdater) {
     initializeTypes(M);
     initializeRuntimeFunctions();
     OMPBuilder.initialize();
   }
-
   /// Generic information that describes a runtime function
   struct RuntimeFunctionInfo {
     /// The kind, as described by the RuntimeFunction enum.
     RuntimeFunction Kind;
 
     /// The name of the function.
     StringRef Name;
 
     /// Flag to indicate a variadic function.
     bool IsVarArg;
 
     /// The return type of the function.
     Type *ReturnType;
 
     /// The argument types of the function.
     SmallVector<Type *, 8> ArgumentTypes;
 
     /// The declaration if available.
     Function *Declaration;
 
     /// Uses of this runtime function per function containing the use.
     DenseMap<Function *, SmallPtrSet<Use *, 16>> UsesMap;
 
     /// Return the number of arguments (or the minimal number for variadic
     /// functions).
     size_t getNumArgs() const { return ArgumentTypes.size(); }
void foreachUse(function_ref<bool(Use &, Function &)> CB) {
           It.second.erase(U);
       }
     }
   };
 
   /// Run all OpenMP optimizations on the underlying SCC/ModuleSlice.
   bool run() {
     bool Changed = false;
-
     LLVM_DEBUG(dbgs() << TAG << "Run on SCC with " << SCC.size()
                       << " functions in a slice with " << ModuleSlice.size()
                       << " functions\n");
 
     Changed |= deduplicateRuntimeCalls();
     Changed |= deleteParallelRegions();
+    Changed |= deleteStaticScheduleCalls();
 
     return Changed;
   }
 
 private:
+  /// Combine "OpenMP for loop with static scheduling"
+  /// TODO: Conditional merging of static scheduler
+  bool deleteStaticScheduleCalls() {
+      /// Data set for storing relative information
+      SmallVector<CallInst *,8> callInst;
+      SmallVector<BasicBlock*,8> basicblock;
+      MapVector<Value*, Value*> store_op0_op1, args_map;
+      MapVector<CallInst*, SmallVector<CallInst *,8>> mapper;
+      MapVector<CallInst*, CallInst*> MapInitFinCI;
+      
+      /// It takes a call instructions and extract arguments that needs to be compared for merging
+      auto BuildArguments = [&] (SmallVector<Value*, 8>& A, CallInst& I){
+          A.clear();
+          for (Value* v: I.args())
+              A.push_back(v);
+      };
+      /// It takes two call instructions and compares for the merging
+      auto CompareTwoInstArgs = [&] (SmallVector<Value*, 8>& A1, SmallVector<Value*, 8>& A2){
+          for (auto i = A1.begin(), j = A2.begin(); i != A1.end() && j!= A2.end(); i++, j++){
+              if (isa<Constant>(*i) && isa<Constant>(*j)){
+                  if ( *i != *j) return false;}
+              else if (store_op0_op1.find(*i)->second != store_op0_op1.find(*j)->second)
+                  return false;}
+          for (auto i = A1.begin(), j = A2.begin(); i != A1.end() && j!= A2.end(); i++, j++)
+              args_map.insert({*j, *i});
+          return true;
+      };
+      /// Prepare information which two call instructions are compatible
+      /// comparing  static_fini_4 call instruction for merging
+      auto CheckTheCompatibility = [&](){
+          SmallVector<Value *, 8> Args1, Args2;
+          SmallVector<CallInst *, 8> CompInst;
+          for (auto i= callInst.begin(); i != callInst.end(); ++i){
+              CompInst.clear();
+              BuildArguments(Args1, **i);
+              for ( auto j = i+1; j != callInst.end(); ++j){
+                  BuildArguments (Args2, **j);
+                  if (CompareTwoInstArgs(Args1, Args2)) {
+                      CompInst.push_back(*j);
+                      callInst.erase(j);j--;
+                  } else {
+                      if (CompInst.size()) mapper.insert({*i, CompInst});
+                      break;}
+              }
+              if (i==callInst.end()-1 && CompInst.size()) mapper.insert({*i, CompInst});
+          }
+          return mapper.size();
+      };
+      /// Clean the redundent call instructions after merging
+      auto CleanInstructions=[&](){
+          for ( auto itr :mapper){
+              int count = (itr.second).size();
+              Instruction *I = MapInitFinCI.find(itr.first)->second;
+              I->eraseFromParent();
+              for (auto itr1 : itr.second){
+                  Instruction *I1 = itr1;
+                  Instruction *I2 = MapInitFinCI.find(itr1)->second;
+                  I1->eraseFromParent();
+                  if ( count==1) break;
+                  I2->eraseFromParent();
+                  count--;}
+          }
+      };
+      /// Replace the redundent register values with the relevent or alive register values after merging and  cleaning
+      auto Replace_UseValues = [&](){
+          SmallVector<Instruction *,8> removeInst, removeIInst;
+          for ( auto b: basicblock)
+              for (BasicBlock::iterator II = b->begin(); II != b->end(); ++II) {
+                  if (IntrinsicInst *I = dyn_cast<IntrinsicInst> (II)){
+                      if (I->getIntrinsicID() == Intrinsic::lifetime_start || I->getIntrinsicID() == Intrinsic::lifetime_end )
+                          removeIInst.push_back(I);continue;}
+                  Instruction *It = dyn_cast<Instruction>(II);
+                  if (isa<CallInst>(It)) continue;
+                  for (unsigned int k = 0; k < It->getNumOperands(); k++){
+                      auto temp =  args_map.find(It->getOperand(k));
+                      if (temp != args_map.end()){
+                          It->setOperand(k, temp->second);
+                          if (isa<StoreInst>(It) && k > 0) removeInst.push_back(It);
+                      }
+              }
+          }
+          for (auto r: removeInst)
+                  r->eraseFromParent();
+          for (auto r: removeIInst)
+                  r->eraseFromParent();
+      };
+      /// Iterate over the all the functions
+      for ( Function *F : SCC){
+          basicblock.clear();
+          for (auto &B: *F){
+              basicblock.push_back(&B);
+              CallInst* last;
+              for (BasicBlock::iterator DI=B.begin(); DI != B.end(); ++DI){
+               if (CallInst *c = dyn_cast<CallInst>(DI))
+               {
+                   if (c->getCalledFunction()->getName() == "__kmpc_for_static_init_4"){
+                       callInst.push_back(c);
+                       last = c;}
+                   else if (c->getCalledFunction()->getName() == "__kmpc_for_static_fini"){
+                       MapInitFinCI.insert({last, c});}
+               }
+               if (StoreInst *store = dyn_cast<StoreInst>(DI))
+                   store_op0_op1.insert({store->getOperand(1),store->getOperand(0)});
+              }
+          }
+      }
+    /// Return TRUE if there IR has been modified
+      if (CheckTheCompatibility()){
+          CleanInstructions();
+          Replace_UseValues();
+          return true;
+      }
+      
+      return false;
+  }
     /// Try to delete parallel regions if possible
   bool deleteParallelRegions() {
     const unsigned CallbackCalleeOperand = 2;
 
     RuntimeFunctionInfo &RFI = RFIs[OMPRTL___kmpc_fork_call];
     if (!RFI.Declaration)
       return false;
 
     bool Changed = false;
void collectGlobalThreadIdArguments(SmallSetVector<Value *, 16> &GTIdArgs) {
     RuntimeFunctionInfo &GlobThreadNumRFI =
         RFIs[OMPRTL___kmpc_global_thread_num];
     for (auto &It : GlobThreadNumRFI.UsesMap)
       for (Use *U : It.second)
         if (CallInst *CI = getCallIfRegularCall(*U, &GlobThreadNumRFI))
           AddUserArgs(*CI);
 
     // Transitively search for more arguments by looking at the users of the
     // ones we know already. During the search the GTIdArgs vector is extended
     // so we cannot cache the size nor can we use a range based for.
     for (unsigned u = 0; u < GTIdArgs.size(); ++u)
       AddUserArgs(*GTIdArgs[u]);
   }
 
   /// Return the call if \p U is a callee use in a regular call. If \p RFI is
   /// given it has to be the callee or a nullptr is returned.
   CallInst *getCallIfRegularCall(Use &U, RuntimeFunctionInfo *RFI = nullptr) {
     CallInst *CI = dyn_cast<CallInst>(U.getUser());
     if (CI && CI->isCallee(&U) && !CI->hasOperandBundles() &&
         (!RFI || CI->getCalledFunction() == RFI->Declaration))
       return CI;

llvm/test/Transforms/OpenMP/parallel_omp_for_loop_merge1.ll

+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; RUN: opt -S  -openmpopt <  %s | FileCheck %s
+; The IR was produced using -O0 and later applying mem2reg, simplifycfg, and instrcombine passes
+;int main(){
+; The last three loops should merged
+;#pragma omp parallel
+;{
+;        #pragma omp for
+;        for (int i=0; i < 100; i++)
+;        ;
+;        #pragma omp for
+;        for (int j=0; j < 10; j++)
+;        ;
+;        #pragma omp for
+;        for (int i=0; i < 10; i++)
+;        ;
+;        #pragma omp for
+;        for (int i=0; i < 10; i++)
+;        ;
+;}
+;        return 0;
+;}
+;
+
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.15.0"
+
+%struct.ident_t = type { i32, i32, i32, i32, i8* }
+
+@0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+@1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 514, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @0, i32 0, i32 0) }, align 8
+@2 = private unnamed_addr constant %struct.ident_t { i32 0, i32 66, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @0, i32 0, i32 0) }, align 8
+@3 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @0, i32 0, i32 0) }, align 8
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define i32 @main() #0 {
+  %1 = alloca i32, align 4
+  store i32 0, i32* %1, align 4
+  call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @3, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
+  ret i32 0
+}
+
+; Function Attrs: noinline norecurse nounwind optnone ssp uwtable
+define internal void @.omp_outlined.(i32* noalias %0, i32* noalias %1) #1 {
+  %3 = alloca i32*, align 8
+  %4 = alloca i32*, align 8
+  %5 = alloca i32, align 4
+  %6 = alloca i32, align 4
+  %7 = alloca i32, align 4
+  %8 = alloca i32, align 4
+  %9 = alloca i32, align 4
+  %10 = alloca i32, align 4
+  %11 = alloca i32, align 4
+  %12 = alloca i32, align 4
+  %13 = alloca i32, align 4
+  %14 = alloca i32, align 4
+  %15 = alloca i32, align 4
+  %16 = alloca i32, align 4
+  %17 = alloca i32, align 4
+  %18 = alloca i32, align 4
+  %19 = alloca i32, align 4
+  %20 = alloca i32, align 4
+  %21 = alloca i32, align 4
+  %22 = alloca i32, align 4
+  %23 = alloca i32, align 4
+  %24 = alloca i32, align 4
+  %25 = alloca i32, align 4
+  %26 = alloca i32, align 4
+  %27 = alloca i32, align 4
+  %28 = alloca i32, align 4
+  %29 = alloca i32, align 4
+  %30 = alloca i32, align 4
+  %31 = alloca i32, align 4
+  %32 = alloca i32, align 4
+  store i32* %0, i32** %3, align 8
+  store i32* %1, i32** %4, align 8
+  store i32 0, i32* %7, align 4
+  store i32 99, i32* %8, align 4
+  store i32 1, i32* %9, align 4
+  store i32 0, i32* %10, align 4
+  %33 = load i32*, i32** %3, align 8
+  %34 = load i32, i32* %33, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @1, i32 %34, i32 34, i32* %10, i32* %7, i32* %8, i32* %9, i32 1, i32 1)
+  %35 = load i32, i32* %8, align 4
+  %36 = icmp sgt i32 %35, 99
+  br i1 %36, label %37, label %38
+
+37:                                               ; preds = %2
+  br label %40
+
+38:                                               ; preds = %2
+  %39 = load i32, i32* %8, align 4
+  br label %40
+
+40:                                               ; preds = %38, %37
+  %41 = phi i32 [ 99, %37 ], [ %39, %38 ]
+  store i32 %41, i32* %8, align 4
+  %42 = load i32, i32* %7, align 4
+  store i32 %42, i32* %5, align 4
+  br label %43
+
+43:                                               ; preds = %52, %40
+  %44 = load i32, i32* %5, align 4
+  %45 = load i32, i32* %8, align 4
+  %46 = icmp sle i32 %44, %45
+  br i1 %46, label %47, label %55
+
+47:                                               ; preds = %43
+  %48 = load i32, i32* %5, align 4
+  %49 = mul nsw i32 %48, 1
+  %50 = add nsw i32 0, %49
+  store i32 %50, i32* %11, align 4
+  br label %51
+
+51:                                               ; preds = %47
+  br label %52
+
+52:                                               ; preds = %51
+  %53 = load i32, i32* %5, align 4
+  %54 = add nsw i32 %53, 1
+  store i32 %54, i32* %5, align 4
+  br label %43
+
+55:                                               ; preds = %43
+  br label %56
+
+56:                                               ; preds = %55
+  call void @__kmpc_for_static_fini(%struct.ident_t* @1, i32 %34)
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %34)
+  store i32 0, i32* %14, align 4
+  store i32 9, i32* %15, align 4
+  store i32 1, i32* %16, align 4
+  store i32 0, i32* %17, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @1, i32 %34, i32 34, i32* %17, i32* %14, i32* %15, i32* %16, i32 1, i32 1)
+  %57 = load i32, i32* %15, align 4
+  %58 = icmp sgt i32 %57, 9
+  br i1 %58, label %59, label %60
+
+59:                                               ; preds = %56
+  br label %62
+
+60:                                               ; preds = %56
+  %61 = load i32, i32* %15, align 4
+  br label %62
+
+62:                                               ; preds = %60, %59
+  %63 = phi i32 [ 9, %59 ], [ %61, %60 ]
+  store i32 %63, i32* %15, align 4
+  %64 = load i32, i32* %14, align 4
+  store i32 %64, i32* %12, align 4
+  br label %65
+
+65:                                               ; preds = %74, %62
+  %66 = load i32, i32* %12, align 4
+  %67 = load i32, i32* %15, align 4
+  %68 = icmp sle i32 %66, %67
+  br i1 %68, label %69, label %77
+
+69:                                               ; preds = %65
+  %70 = load i32, i32* %12, align 4
+  %71 = mul nsw i32 %70, 1
+  %72 = add nsw i32 0, %71
+  store i32 %72, i32* %18, align 4
+  br label %73
+
+73:                                               ; preds = %69
+  br label %74
+
+74:                                               ; preds = %73
+  %75 = load i32, i32* %12, align 4
+  %76 = add nsw i32 %75, 1
+  store i32 %76, i32* %12, align 4
+  br label %65
+
+77:                                               ; preds = %65
+  br label %78
+
+78:                                               ; preds = %77
+  call void @__kmpc_for_static_fini(%struct.ident_t* @1, i32 %34)
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %34)
+  store i32 0, i32* %21, align 4
+  store i32 9, i32* %22, align 4
+  store i32 1, i32* %23, align 4
+  store i32 0, i32* %24, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @1, i32 %34, i32 34, i32* %24, i32* %21, i32* %22, i32* %23, i32 1, i32 1)
+  %79 = load i32, i32* %22, align 4
+  %80 = icmp sgt i32 %79, 9
+  br i1 %80, label %81, label %82
+
+81:                                               ; preds = %78
+  br label %84
+
+82:                                               ; preds = %78
+  %83 = load i32, i32* %22, align 4
+  br label %84
+
+84:                                               ; preds = %82, %81
+  %85 = phi i32 [ 9, %81 ], [ %83, %82 ]
+  store i32 %85, i32* %22, align 4
+  %86 = load i32, i32* %21, align 4
+  store i32 %86, i32* %19, align 4
+  br label %87
+
+87:                                               ; preds = %96, %84
+  %88 = load i32, i32* %19, align 4
+  %89 = load i32, i32* %22, align 4
+  %90 = icmp sle i32 %88, %89
+  br i1 %90, label %91, label %99
+
+91:                                               ; preds = %87
+  %92 = load i32, i32* %19, align 4
+  %93 = mul nsw i32 %92, 1
+  %94 = add nsw i32 0, %93
+  store i32 %94, i32* %25, align 4
+  br label %95
+
+95:                                               ; preds = %91
+  br label %96
+
+96:                                               ; preds = %95
+  %97 = load i32, i32* %19, align 4
+  %98 = add nsw i32 %97, 1
+  store i32 %98, i32* %19, align 4
+  br label %87
+
+99:                                               ; preds = %87
+  br label %100
+
+100:                                              ; preds = %99
+  call void @__kmpc_for_static_fini(%struct.ident_t* @1, i32 %34)
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %34)
+  store i32 0, i32* %28, align 4
+  store i32 9, i32* %29, align 4
+  store i32 1, i32* %30, align 4
+  store i32 0, i32* %31, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @1, i32 %34, i32 34, i32* %31, i32* %28, i32* %29, i32* %30, i32 1, i32 1)
+  %101 = load i32, i32* %29, align 4
+  %102 = icmp sgt i32 %101, 9
+  br i1 %102, label %103, label %104
+
+103:                                              ; preds = %100
+  br label %106
+
+104:                                              ; preds = %100
+  %105 = load i32, i32* %29, align 4
+  br label %106
+
+106:                                              ; preds = %104, %103
+  %107 = phi i32 [ 9, %103 ], [ %105, %104 ]
+  store i32 %107, i32* %29, align 4
+  %108 = load i32, i32* %28, align 4
+  store i32 %108, i32* %26, align 4
+  br label %109
+
+109:                                              ; preds = %118, %106
+  %110 = load i32, i32* %26, align 4
+  %111 = load i32, i32* %29, align 4
+  %112 = icmp sle i32 %110, %111
+  br i1 %112, label %113, label %121
+
+113:                                              ; preds = %109
+  %114 = load i32, i32* %26, align 4
+  %115 = mul nsw i32 %114, 1
+  %116 = add nsw i32 0, %115
+  store i32 %116, i32* %32, align 4
+  br label %117
+
+117:                                              ; preds = %113
+  br label %118
+
+118:                                              ; preds = %117
+  %119 = load i32, i32* %26, align 4
+  %120 = add nsw i32 %119, 1
+  store i32 %120, i32* %26, align 4
+  br label %109
+
+121:                                              ; preds = %109
+  br label %122
+
+122:                                              ; preds = %121
+  call void @__kmpc_for_static_fini(%struct.ident_t* @1, i32 %34)
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %34)
+  ret void
+}
+
+declare void @__kmpc_for_static_init_4(%struct.ident_t*, i32, i32, i32*, i32*, i32*, i32*, i32, i32)
+
+; Function Attrs: nounwind
+declare void @__kmpc_for_static_fini(%struct.ident_t*, i32) #2
+
+; Function Attrs: convergent nounwind
+declare void @__kmpc_barrier(%struct.ident_t*, i32) #3
+
+; Function Attrs: nounwind
+declare !callback !4 void @__kmpc_fork_call(%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) #2
+
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.ident = !{!3}
+
+!0 = !{i32 2, !"SDK Version", [2 x i32] [i32 10, i32 15]}
+!1 = !{i32 1, !"wchar_size", i32 4}
+!2 = !{i32 7, !"PIC Level", i32 2}
+!3 = !{!"clang version 12.0.0 (https://github.com/llvm/llvm-project.git 979bcbd3a6f7ea784f2098ad4cf613fbd6b09e38)"}
+!4 = !{!5}
+!5 = !{i64 2, i64 -1, i64 -1, i1 true}
+
+;
+; CHECK: call void @__kmpc_for_static_init_4(
+; CHECK: call void @__kmpc_for_static_fini(
+; CHECK: call void @__kmpc_barrier(
+; CHECK: call void @__kmpc_for_static_init_4(
+; CHECK-NOT: call void @__kmpc_for_static_fini(
+; CHECK: call void @__kmpc_barrier(
+; CHECK-NOT: call void @__kmpc_for_static_init_4(
+; CHECK-NOT: call void @__kmpc_for_static_fini(
+; CHECK: call void @__kmpc_barrier(
+; CHECK-NOT: call void @__kmpc_for_static_init_4(
+; CHECK: call void @__kmpc_for_static_fini(
+; CHECK: call void @__kmpc_barrier(
+; CHECK:    ret void
+;
+
+

openmp/runtime/src/kmp_sched.cpp

 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_team_info_t *team_info = NULL;
   ompt_task_info_t *task_info = NULL;
   ompt_work_t ompt_work_type = ompt_work_loop;
 
   static kmp_int8 warn = 0;
 
+
   if (ompt_enabled.ompt_callback_work) {
     // Only fully initialize variables needed by OMPT if OMPT is enabled.
     team_info = __ompt_get_teaminfo(0, NULL);
     task_info = __ompt_get_task_info_object(0);
     // Determine workshare type
     if (loc != NULL) {
       if ((loc->flags & KMP_IDENT_WORK_LOOP) != 0) {
         ompt_work_type = ompt_work_loop;