[OpenMP] Add !range metadata to loads from omp.(ub/lb)

[kaushikcfd]

Summary

After invoking kmpc_for_static_init_4, values in omp.ub and omp.lb are bound by the bounds of the sequential loop. This information is passed to the IR by setting the !range metadata of the corresponding variables.

[jdoerfert]

This looks pretty good already. I inlined some comments. We also need negative tests, e.g., with non-constant loop bounds.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

48

We should add a statistics tracker for annotated loops.

107

The documentation here needs improvement. If the callback returns true the use will be deleted. Could you augment the documentation and make sure you don't cause uses to be removed from the cache.

220

We still use capital first letters for characters, thus SetRangeCB and StaticForCall, ...

223

We need names for these "magic constants" maybe some globals like this:

static constexpr unsigned KMPC_FOR_STATIC_INIT_LB = 4;
static constexpr unsigned KMPC_FOR_STATIC_INIT_UB = 5;

226

Nit: I somehow would prefer nullptr instead of NULL.

251

You need to verify there is only a single load/store and the value is an alloca without initializer and the type is as expected.

280

Style: Early exists are easier to read, so:

if (cond) {
  DEBUG(...);
  return;
}

llvm/test/Transforms/OpenMP/set_bound_ranges.ll

101

I think you can remove the attributes and metadata above.

[kaushikcfd]

Post review amends:

• Doesn't delete the use after adding the range
• Added a negative test
• Satisfies Linter

[kaushikcfd]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

251

verify there is only a single load/store

There might be multiple loads/store to %omp.ub arising from EnsureUpperBound. So, we only pick the store just before and the load just after the static_for invocation.

value is an alloca without initializer

Is the "value" begin discussed here V?

[sstefan1]

Seems like you uploaded a diff against your previous patch version. Also changes from OMPKinds.def are missing. Can you fix that?

[sstefan1]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

224

for (const Use &U : BoundVal->uses()) seems nicer.

[jdoerfert]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

47

-for
+worksharing

208

no else after return

213

Either move these dyn_cast prior to the conditional and branch on Low and HighMinusOne (which are nullptr if they are not constant ints), or use cast here because you had a isa before. I would probably do the former.

221

We should check that this is better than the existing metadata.

223

move them into the class or global scope.

224

Right. And if you only want the users: users().

251

If there are multiple, how do you ensure you pick up the right one? We probably need to find all and use the upper/lower bound of all stored values to be correct. We also need a test for multiple loads/stores.

I mean we assume OMPLBVal and OMPUBVal are alloca's, right? We need to make sure we only pattern match a situation we can "control"

[kaushikcfd]

Fixes the "updated" diff for the previous version.

[kaushikcfd]

Seems like you uploaded a diff against your previous patch version

Thanks @sstefan1, indeed I confused updated diff as being the iterative update. Should be fixed now.

[kaushikcfd]

Address review comments. (thanks @jdoerfert , @sstefan1!)

[kaushikcfd]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

251

Agreed, the current implementation is broken. I've added a FIXME for it. Looks like we should do some dataflow analysis to figure out the correct range.

I mean we assume OMPLBVal and OMPUBVal are alloca's, right?

Yep, made the assumption explicit in the latest revision.

[jdoerfert]

Sorry for the delay. I'm usually faster.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

212

asserts need a message.

232

In this patch or a follow up we need to do this for the other loop init runtime calls as well (there are 4 or 8 I think).

251

No "FIXME" for correctness issues please. "FIXME" is fine for required improvements though.
So, the case we can handle correctly now we should. We should also detect if it is not one of them and give up, e.g., if there are more than a single load and store. I recommend just tracking all uses, determining if it is a load of the pointer or a store *to the pointer* (not of it), putting them in respective sets, and bailing on other uses. Then, inspect the loads/stores, for now just bail if the number is not one for each.

We should have a test with a FIXME as well to show what is missing.

313

Style: I would prefer if (is..) { changed = true; ... } as it makes the code easier to read (for me).

315

This will not count the right thing if the first loop is annotated but no other one.

[kaushikcfd]

• Fixes correctness issues in calculating NumLoopsAnnotated
• Adds an error message to assert

[kaushikcfd]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

251

The "FIXME" was meant to be handled before getting this merged in. (this is in process of being solved, will ping once I've put in the solution)

[jdoerfert]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

247

Style: I would move the comment before the if or add braces.

I'm curious, is this a widely occurring case? Do you know when it occurs in practice?

251

Sounds good :) I will monitor the reviews more closely now anyway.

[kaushikcfd]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

247

I'm curious, is this a widely occurring case? Do you know when it occurs in practice?

I'm sorry, the comment is a bit misleading. I mean't that -- we support adding ranges to a simple but widely occurring case. In my experience, any pragmas that are translated through clang should have OMPLBVal/OMPUBVal as allocas. Will rephrase it.

[kaushikcfd]

1. Corrects the logic behind getting the ranges of stores to omp.(ub/lb).
2. Corrects the comment explaining we only support adding range to cases when omp.(ub/lb) are allocas.

[kaushikcfd]

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

232

I would prefer I do that in a followup patch. It would be easier if we keep this patch only for checking the correctness of logic behind setting the range of bounds.

[jdoerfert]

The entire potentially reachable thing breaks down if you put the omp for into another loop, doesn't it? Everything becomes potentially reachable from everything.
The situation you are after is, as far as I understand, as follows:

store x in UB
call __kmpc_for_init_4(...)
v = load UB
store min(v, x) in UB

correct?

Two alternative approaches:

1. move the min computation (if necessary) into __kmpc_for_init_4 so we don't see it here. All we would see is a single store. (=make sure the call never returns a value higher than the given upper bound) [preferred if plausible]
2. match the pattern manually. Two stores, one with a value the other with a select that implements a min. The load flowing into the min needs to (directly) follow the call, the compare etc. So the instruction sequence after the call needs to be

call void @__kmpc_for_static_init_4(%struct.ident_t* nonnull @0, i32 %0, i32 34, i32* nonnull %.omp.is_last, i32* nonnull %.omp.lb, i32* nonnull %.omp.ub, i32* nonnull %.omp.stride, i32 1, i32 1)
%1 = load i32, i32* %.omp.ub, align 4
%2 = icmp slt i32 %1, 195
%cond = select i1 %2, i32 %1, i32 195
store i32 %cond, i32* %.omp.ub, align 4

My earlier suggestion with te must-be-executed-context was a generalization of 2). You can also do it more general without the context:

• Both stores are in the same block, on before one after the call, the second one stores the min expression, only the load that flows into the min is between the call and the second store.

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

288

I guess this can just be a member function.

llvm/test/Transforms/OpenMP/set_bound_ranges.ll

3

manually run -simplifycfg on this file to get rid of the control flow in favor of selects and then -instcombine to remove redundant loads.

[kaushikcfd]

• Another attempt at making logic, for finding the right loads/stores, general enough to handle all the cases emitted by Clang.
  • Now looks for loads/stores to omp.(ub.lb) only in the same basic block as '__kmpc_for_static_init_4'.
  • Required slight changes in the OpenMP part of Clang to make sure that it fits this pattern.
• Included a test to check setting the ranges of an OpenMP for-directive that has compile-time constant bounds and is enclosed in an outer loop.

[kaushikcfd]

In D75893#1932813, @jdoerfert wrote:

Thanks for taking a look at it!

The entire potentially reachable thing breaks down if you put the omp for into another loop, doesn't it? Everything becomes potentially reachable from everything.

Unfortunately yes, it would've led to not setting the ranges of any loads from omp.(lb/ub).

The situation you are after is, as far as I understand, as follows:

store x in UB
call __kmpc_for_init_4(...)
v = load UB
store min(v, x) in UB

correct?

Two alternative approaches:

1. move the min computation (if necessary) into __kmpc_for_init_4 so we don't see it here. All we would see is a single store. (=make sure the call never returns a value higher than the given upper bound) [preferred if plausible]

The newest patch does some minor changes in Clang to have it covered in our pattern-matching, which turned out to be easier than this. Lmk if you have any problems with it.

llvm/test/Transforms/OpenMP/set_bound_ranges.ll

3

Running these passes might not check the true IR fed from Clang to -openmpopt, which is the use case we are shooting for.

[jdoerfert]

clang/lib/CodeGen/CGStmtOpenMP.cpp

2739 ↗

(On Diff #252958)

How did this help? There must be test changes in clang, right?

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

258

Checking via operands of instructions that are skipped doesn't work in general. You could have a bitcast or anything that "hides" the pointer even though it is used. I think we should be more conservative as this is a pattern. Only skip loads and stores and only if the loaded/stored pointer is an alloca different from what what we look at. Everything else is a reason to bail

[kaushikcfd]

clang/lib/CodeGen/CGStmtOpenMP.cpp

2739 ↗

(On Diff #252958)

All the loads to %omp.(lb,ub), would now lie in the same BB as kmpc_for_static_init_4, fitting our pattern in OpenMPOpt.

There must be test changes in clang, right?

Possibly, I should take a look on that front. (If we are looking for an easier pattern to match we would've incurred this problem one way or the other.)

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

 #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, false, Int32, IdentPtr, Int32, 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_for_static_init_4, false, Void, IdentPtr,
+    Int32 /*gtid*/, Int32 /*sched_type*/,
+    Int32Ptr /*plastiter*/,
+    Int32Ptr /*plower*/, Int32Ptr /*pupper*/, Int32Ptr /*pstride*/,
+    Int32 /*incr*/, Int32 /*chunk*/)
 __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)

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

static cl::opt<bool> DisableOpenMPOptimizations(
     cl::init(false));
 
 STATISTIC(NumOpenMPRuntimeCallsDeduplicated,
           "Number of OpenMP runtime calls deduplicated");
 STATISTIC(NumOpenMPRuntimeFunctionsIdentified,
           "Number of OpenMP runtime functions identified");
 STATISTIC(NumOpenMPRuntimeFunctionUsesIdentified,
           "Number of OpenMP runtime function uses identified");
+STATISTIC(NumOpenMPLoopsRangeAnnotated,
+          "Number of OpenMP for directives annotated with !range");
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 static constexpr auto TAG = "[" DEBUG_TYPE "]";
 #endif
 
 namespace {
 struct OpenMPOpt {
 
   OpenMPOpt(SmallPtrSetImpl<Function *> &SCC,
struct RuntimeFunctionInfo {
 
     /// 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(); }
 
-    /// Run the callback \p CB on each use and forget the use if the result is
+    /// Run the callback \p CB on each use and forget the use if CB returns
     /// true. The callback will be fed the function in which the use was
     /// encountered as second argument.
     void foreachUse(function_ref<bool(Use &, Function &)> CB) {
       SmallVector<Use *, 8> ToBeDeleted;
       for (auto &It : UsesMap) {
         ToBeDeleted.clear();
         for (Use *U : It.second)
           if (CB(*U, *It.first))
             ToBeDeleted.push_back(U);
         for (Use *U : ToBeDeleted)
           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 |= addRangeMetadataToOMPLoopBounds();
 
     return Changed;
   }
 
 private:
   /// Try to delete parallel regions if possible
   bool deleteParallelRegions() {
     const unsigned CallbackCalleeOperand = 2;
for (Function *F : SCC) {
         }
       Changed |= deduplicateRuntimeCalls(
           *F, RFIs[OMPRTL___kmpc_global_thread_num], GTIdArg);
     }
 
     return Changed;
   }
 
+  /// Adds range metadata to loads and stores of the omp.(ub/lb).
+  /// A conservative range is set by setting the range equal to iteration
+  /// space of the underlying loop.
+  bool addRangeMetadataToOMPLoopBounds() {
+    bool Changed = false;
+    RuntimeFunctionInfo &RFI = RFIs[OMPRTL___kmpc_for_static_init_4];
+
+    if (!RFI.Declaration)
+      return false;
+
+    auto SetRangeCB = [&](Use &U, Function &F) {
+      CallInst *StaticForCall = getCallIfRegularCall(U);
+      if (!StaticForCall)
+        return false;
+
+      static constexpr unsigned KMPC_FOR_STATIC_INIT_LB = 4;
+      static constexpr unsigned KMPC_FOR_STATIC_INIT_UB = 5;
+
+      Value *OMPLBVal = StaticForCall->getArgOperand(KMPC_FOR_STATIC_INIT_LB);
+      Value *OMPUBVal = StaticForCall->getArgOperand(KMPC_FOR_STATIC_INIT_UB);
+
+      StoreInst *StoreToLB = nullptr, *StoreToUB = nullptr;
+      LoadInst *LoadFromLB = nullptr, *LoadFromUB = nullptr;
+
+      /// GetLoadStoreGuardingStaticFor: sets nearest store to 'BoundVal'
+      /// preceding 'StaticForCall' & nearest load to 'BoundVal' succeeding
+      /// StaticForCall'
+      auto GetLoadStoreGuardingStaticFor = [StaticForCall](Value *BoundVal,
+                                                           LoadInst *&Load,
+                                                           StoreInst *&Store) {
+        bool FoundCall = false;
+        Value::use_iterator I = BoundVal->use_begin(), E = BoundVal->use_end();
+
+        for (; I != E; ++I) {
+          Value *V = I->getUser();
+          if (!FoundCall) {
+            if (V == StaticForCall)
+              FoundCall = true;
+            else if (isa<LoadInst>(V))
+              Load = dyn_cast<LoadInst>(V);
+          } else {
+            if (isa<StoreInst>(V)) {
+              Store = dyn_cast<StoreInst>(V);
+              break;
+            }
+          }
+        }
+      };
+
+      GetLoadStoreGuardingStaticFor(OMPLBVal, LoadFromLB, StoreToLB);
+      GetLoadStoreGuardingStaticFor(OMPUBVal, LoadFromUB, StoreToUB);
+
+      if (!isa<ConstantInt>(StoreToLB->getValueOperand()) ||
+          !isa<ConstantInt>(StoreToUB->getValueOperand())) {
+        LLVM_DEBUG(
+            dbgs()
+            << "[addRangeMetadataToOMPLoopBounds]: Unable to set the ranges"
+            << " as the iteration zone of '" << *StaticForCall
+            << "' isn't compile time constant.\n");
+        return false;
+      } else {
+        LLVMContext &Context = StaticForCall->getParent()->getContext();
+
+        ConstantInt *Low = dyn_cast<ConstantInt>(StoreToLB->getValueOperand());
+        ConstantInt *HighMinusOne =
+            dyn_cast<ConstantInt>(StoreToUB->getValueOperand());
+        ConstantInt *High = ConstantInt::get(
+            HighMinusOne->getType(), (HighMinusOne->getSExtValue()) + 1);
+
+        Metadata *LowAndHigh[] = {
+            ConstantAsMetadata::get(Low),
+            ConstantAsMetadata::get(High),
+        };
+        LoadFromLB->setMetadata(LLVMContext::MD_range,
+                                MDNode::get(Context, LowAndHigh));
+        LoadFromUB->setMetadata(LLVMContext::MD_range,
+                                MDNode::get(Context, LowAndHigh));
+        Changed = true;
+        ++NumOpenMPLoopsRangeAnnotated;
+      }
+
+      // Don't clear 'Use U' in 'UsesMap'
+      return false;
+    };
+
+    RFI.foreachUse(SetRangeCB);
+    return Changed;
+  }
+
   static Value *combinedIdentStruct(Value *Ident0, Value *Ident1,
                                     bool GlobalOnly) {
     // TODO: Figure out how to actually combine multiple debug locations. For
     //       now we just keep the first we find.
     if (Ident0)
       return Ident0;
     if (!GlobalOnly || isa<GlobalValue>(Ident1))
       return Ident1;
     return nullptr;
   }
 
   /// Return an `struct ident_t*` value that represents the ones used in the
   /// calls of \p RFI inside of \p F. If \p GlobalOnly is true, we will not
   /// return a local `struct ident_t*`. For now, if we cannot find a suitable
   /// return value we create one from scratch. We also do not yet combine
   /// information, e.g., the source locations, see combinedIdentStruct.
   Value *getCombinedIdentFromCallUsesIn(RuntimeFunctionInfo &RFI, Function &F,
                                         bool GlobalOnly) {
     Value *Ident = nullptr;
     auto CombineIdentStruct = [&](Use &U, Function &Caller) {
       CallInst *CI = getCallIfRegularCall(U, &RFI);
       if (!CI || &F != &Caller)
         return false;
       Ident = combinedIdentStruct(Ident, CI->getArgOperand(0),
                                   /* GlobalOnly */ true);
       return false;
     };
     RFI.foreachUse(CombineIdentStruct);

llvm/test/Transforms/OpenMP/set_bound_ranges.ll

+; RUN: opt -openmpopt -S < %s | FileCheck %s
+; RUN: opt -passes=openmpopt -S < %s | FileCheck %s
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+%struct.ident_t = type { i32, i32, i32, i32, i8* }
+
+@.str = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+@0 = private unnamed_addr global %struct.ident_t { i32 0, i32 514, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i32 0, i32 0) }, align 8
+@1 = private unnamed_addr global %struct.ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i32 0, i32 0) }, align 8
+@2 = private unnamed_addr global %struct.ident_t { i32 0, i32 66, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i32 0, i32 0) }, align 8
+
+define dso_local void @foo(i32 %N) {
+;CHECK: void @foo(
+entry:
+  %N.addr = alloca i32, align 4
+  %.omp.iv = alloca i32, align 4
+  %tmp = alloca i32, align 4
+  %.omp.lb = alloca i32, align 4
+  %.omp.ub = alloca i32, align 4
+  %.omp.stride = alloca i32, align 4
+  %.omp.is_last = alloca i32, align 4
+  %i = alloca i32, align 4
+  %0 = call i32 @__kmpc_global_thread_num(%struct.ident_t* @1)
+  store i32 %N, i32* %N.addr, align 4
+  store i32 0, i32* %.omp.lb, align 4
+  store i32 195, i32* %.omp.ub, align 4
+  store i32 1, i32* %.omp.stride, align 4
+  store i32 0, i32* %.omp.is_last, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @0, i32 %0, i32 34, i32* %.omp.is_last, i32* %.omp.lb, i32* %.omp.ub, i32* %.omp.stride, i32 1, i32 1)
+  %1 = load i32, i32* %.omp.ub, align 4
+; CHECK: %1 = load i32, i32* %.omp.ub, align 4, !range ![[RANGE0:[0-9]+]]
+  %cmp = icmp sgt i32 %1, 195
+  br i1 %cmp, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  %2 = load i32, i32* %.omp.ub, align 4
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi i32 [ 195, %cond.true ], [ %2, %cond.false ]
+  store i32 %cond, i32* %.omp.ub, align 4
+  %3 = load i32, i32* %.omp.lb, align 4
+; CHECK: %3 = load i32, i32* %.omp.lb, align 4, !range ![[RANGE0]]
+  store i32 %3, i32* %.omp.iv, align 4
+  br label %omp.inner.for.cond
+
+omp.inner.for.cond:                               ; preds = %omp.inner.for.inc, %cond.end
+  %4 = load i32, i32* %.omp.iv, align 4
+  %5 = load i32, i32* %.omp.ub, align 4
+  %cmp1 = icmp sle i32 %4, %5
+  br i1 %cmp1, label %omp.inner.for.body, label %omp.inner.for.end
+
+omp.inner.for.body:                               ; preds = %omp.inner.for.cond
+  %6 = load i32, i32* %.omp.iv, align 4
+  %mul = mul nsw i32 %6, 1
+  %add = add nsw i32 0, %mul
+  store i32 %add, i32* %i, align 4
+  %call = call i32 (...) @bar()
+  br label %omp.body.continue
+
+omp.body.continue:                                ; preds = %omp.inner.for.body
+  br label %omp.inner.for.inc
+
+omp.inner.for.inc:                                ; preds = %omp.body.continue
+  %7 = load i32, i32* %.omp.iv, align 4
+  %add2 = add nsw i32 %7, 1
+  store i32 %add2, i32* %.omp.iv, align 4
+  br label %omp.inner.for.cond
+
+omp.inner.for.end:                                ; preds = %omp.inner.for.cond
+  br label %omp.loop.exit
+
+omp.loop.exit:                                    ; preds = %omp.inner.for.end
+  call void @__kmpc_for_static_fini(%struct.ident_t* @0, i32 %0)
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %0)
+  ret void
+}
+
+declare dso_local i32 @__kmpc_global_thread_num(%struct.ident_t*)
+
+declare dso_local void @__kmpc_for_static_init_4(%struct.ident_t*, i32, i32, i32*, i32*, i32*, i32*, i32, i32)
+
+declare dso_local i32 @bar(...)
+
+declare dso_local void @__kmpc_for_static_fini(%struct.ident_t*, i32)
+
+declare dso_local void @__kmpc_barrier(%struct.ident_t*, i32)
+
+define dso_local void @test_runtime_it_space(i32 %N) {
+;CHECK: void @test_runtime_it_space(
+entry:
+  %N.addr = alloca i32, align 4
+  %.omp.iv = alloca i32, align 4
+  %tmp = alloca i32, align 4
+  %.capture_expr. = alloca i32, align 4
+  %.capture_expr.1 = alloca i32, align 4
+  %i = alloca i32, align 4
+  %.omp.lb = alloca i32, align 4
+  %.omp.ub = alloca i32, align 4
+  %.omp.stride = alloca i32, align 4
+  %.omp.is_last = alloca i32, align 4
+  %i4 = alloca i32, align 4
+  %0 = call i32 @__kmpc_global_thread_num(%struct.ident_t* @1)
+  store i32 %N, i32* %N.addr, align 4
+  %1 = load i32, i32* %N.addr, align 4
+  store i32 %1, i32* %.capture_expr., align 4
+  %2 = load i32, i32* %.capture_expr., align 4
+  %sub = sub nsw i32 %2, 0
+  %sub2 = sub nsw i32 %sub, 1
+  %add = add nsw i32 %sub2, 1
+  %div = sdiv i32 %add, 1
+  %sub3 = sub nsw i32 %div, 1
+  store i32 %sub3, i32* %.capture_expr.1, align 4
+  store i32 0, i32* %i, align 4
+  %3 = load i32, i32* %.capture_expr., align 4
+  %cmp = icmp slt i32 0, %3
+  br i1 %cmp, label %omp.precond.then, label %omp.precond.end
+
+omp.precond.then:                                 ; preds = %entry
+  store i32 0, i32* %.omp.lb, align 4
+  %4 = load i32, i32* %.capture_expr.1, align 4
+  store i32 %4, i32* %.omp.ub, align 4
+  store i32 1, i32* %.omp.stride, align 4
+  store i32 0, i32* %.omp.is_last, align 4
+  call void @__kmpc_for_static_init_4(%struct.ident_t* @0, i32 %0, i32 34, i32* %.omp.is_last, i32* %.omp.lb, i32* %.omp.ub, i32* %.omp.stride, i32 1, i32 1)
+  %5 = load i32, i32* %.omp.ub, align 4
+;CHECK: %5 = load i32, i32* %.omp.ub, align 4
+;CHECK-NOT: !range
+  %6 = load i32, i32* %.capture_expr.1, align 4
+  %cmp5 = icmp sgt i32 %5, %6
+  br i1 %cmp5, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %omp.precond.then
+  %7 = load i32, i32* %.capture_expr.1, align 4
+  br label %cond.end
+
+cond.false:                                       ; preds = %omp.precond.then
+  %8 = load i32, i32* %.omp.ub, align 4
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi i32 [ %7, %cond.true ], [ %8, %cond.false ]
+  store i32 %cond, i32* %.omp.ub, align 4
+  %9 = load i32, i32* %.omp.lb, align 4
+;CHECK: %9 = load i32, i32* %.omp.lb, align 4
+;CHECK-NOT: !range
+  store i32 %9, i32* %.omp.iv, align 4
+  br label %omp.inner.for.cond
+
+omp.inner.for.cond:                               ; preds = %omp.inner.for.inc, %cond.end
+  %10 = load i32, i32* %.omp.iv, align 4
+  %11 = load i32, i32* %.omp.ub, align 4
+  %cmp6 = icmp sle i32 %10, %11
+  br i1 %cmp6, label %omp.inner.for.body, label %omp.inner.for.end
+
+omp.inner.for.body:                               ; preds = %omp.inner.for.cond
+  %12 = load i32, i32* %.omp.iv, align 4
+  %mul = mul nsw i32 %12, 1
+  %add7 = add nsw i32 0, %mul
+  store i32 %add7, i32* %i4, align 4
+  %call = call i32 (...) @baz()
+  br label %omp.body.continue
+
+omp.body.continue:                                ; preds = %omp.inner.for.body
+  br label %omp.inner.for.inc
+
+omp.inner.for.inc:                                ; preds = %omp.body.continue
+  %13 = load i32, i32* %.omp.iv, align 4
+  %add8 = add nsw i32 %13, 1
+  store i32 %add8, i32* %.omp.iv, align 4
+  br label %omp.inner.for.cond
+
+omp.inner.for.end:                                ; preds = %omp.inner.for.cond
+  br label %omp.loop.exit
+
+omp.loop.exit:                                    ; preds = %omp.inner.for.end
+  call void @__kmpc_for_static_fini(%struct.ident_t* @0, i32 %0)
+  br label %omp.precond.end
+
+omp.precond.end:                                  ; preds = %omp.loop.exit, %entry
+  call void @__kmpc_barrier(%struct.ident_t* @2, i32 %0)
+  ret void
+;CHECK: ret void
+}
+
+declare dso_local i32 @baz(...)
+
+
+; CHECK: ![[RANGE0]] = !{i32 0, i32 196}