[SCCP] Skip unknown values depending on tracked functions.

[fhahn]

Summary

We do not resolve undefs for tracked functions in ResolvedUndefsIn. For
instructions that depend on results of tracked functions, we can skip
them in ResolvedUndefsIn, to avoid going to overdefined before we know
the function result. This allows us to cover a few more cases. This
should be safe; once we resolved the call result, we propagate it to all
users. Note that phis depending on tracked functions will still be
marked as overdefined early in some cases (e.g. loops).

Similarly, we can skip instructions depending on unknown function
arguments for tracked functions.

Before marking it as ready for review, I'd like to do some additional
testing.

[jdoerfert]

llvm/lib/Transforms/Scalar/SCCP.cpp

1446

Out of scope: Isn't branch on undef UB?

llvm/test/Transforms/SCCP/resolvedundefsin-tracked-fn.ll

1

Nit: You should probably do an NFC commit first to add the --function-signatures

[fhahn]

llvm/lib/Transforms/Scalar/SCCP.cpp

1446

I don't think so. undef just indicates that the user of the value may receive an unspecified bit-patter'. IUUC we are only free to pick either the true/false destination, by replacing the condition with true/false. Note that we have to make sure we replace the undef if we make the assumption. If the branch on undef remains, the other branch might be (assumed as) taken, potentially leading to a contradiction further down the line.

Branches on poison values are UB.

llvm/test/Transforms/SCCP/resolvedundefsin-tracked-fn.ll

1

I'll do that. Initially I just tweaked the check lines to include the define, because update_test_checks.py defaults just check for the function name, causing FIleCheck to fail unexpectedly if the function is called before being defined.

I only just discovered --function-signature does what I want :)

llvm/lib/Transforms/Scalar/SCCP.cpp

while (!BBWorkList.empty() || !InstWorkList.empty() ||
     }
   }
 }
 
 /// ResolvedUndefsIn - While solving the dataflow for a function, we assume
 /// that branches on undef values cannot reach any of their successors.
 /// However, this is not a safe assumption.  After we solve dataflow, this
 /// method should be use to handle this.  If this returns true, the solver
 /// should be rerun.
 ///
 /// This method handles this by finding an unresolved branch and marking it one
 /// of the edges from the block as being feasible, even though the condition
 /// doesn't say it would otherwise be.  This allows SCCP to find the rest of the
 /// CFG and only slightly pessimizes the analysis results (by marking one,
 /// potentially infeasible, edge feasible).  This cannot usefully modify the
 /// constraints on the condition of the branch, as that would impact other users
 /// of the value.
 ///
 /// This scan also checks for values that use undefs. It conservatively marks
 /// them as overdefined.
 bool SCCPSolver::ResolvedUndefsIn(Function &F) {
+  // Keep track of values that dependent on an yet unknown tracked function
+  // call. It only makes sense to resolve them once the call is resolved.
+  SmallPtrSet<Value *, 8> DependsOnSkipped;
+  for (auto &A : F.args()) {
+    if (A.getType()->isStructTy() || !getValueState(&A).isUnknown())
+      continue;
+    DependsOnSkipped.insert(&A);
+  }
   for (BasicBlock &BB : F) {
     if (!BBExecutable.count(&BB))
       continue;
 
     for (Instruction &I : BB) {
       // Look for instructions which produce undef values.
       if (I.getType()->isVoidTy()) continue;
 
       if (auto *STy = dyn_cast<StructType>(I.getType())) {
         // Only a few things that can be structs matter for undef.
 
         // Tracked calls must never be marked overdefined in ResolvedUndefsIn.
         if (CallSite CS = CallSite(&I))
           if (Function *F = CS.getCalledFunction())
-            if (MRVFunctionsTracked.count(F))
+            if (MRVFunctionsTracked.count(F)) {
+              DependsOnSkipped.insert(&I);
               continue;
+            }
 
         // extractvalue and insertvalue don't need to be marked; they are
         // tracked as precisely as their operands.
         if (isa<ExtractValueInst>(I) || isa<InsertValueInst>(I))
           continue;
         // Send the results of everything else to overdefined.  We could be
         // more precise than this but it isn't worth bothering.
         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
for (Instruction &I : BB) {
 
       // There are two reasons a call can have an undef result
       // 1. It could be tracked.
       // 2. It could be constant-foldable.
       // Because of the way we solve return values, tracked calls must
       // never be marked overdefined in ResolvedUndefsIn.
       if (CallSite CS = CallSite(&I))
         if (Function *F = CS.getCalledFunction())
-          if (TrackedRetVals.count(F))
+          if (TrackedRetVals.count(F)) {
+            DependsOnSkipped.insert(&I);
             continue;
+          }
+
+      // Skip instructions that depend on results of calls we skipped earlier.
+      // Otherwise we might mark I as overdefined to early when we would end up
+      // discovering a constant value for I, if the call later resolves to a
+      // constant.
+      if (any_of(I.operands(), [&DependsOnSkipped](Value *V) {
+            return DependsOnSkipped.find(V) != DependsOnSkipped.end();
+          })) {
+        DependsOnSkipped.insert(&I);
+        continue;
+      }
 
       markOverdefined(&I);
       return true;
     }
 
     // Check to see if we have a branch or switch on an undefined value.  If so
     // we force the branch to go one way or the other to make the successor
     // values live.  It doesn't really matter which way we force it.

llvm/test/Transforms/SCCP/ipsccp-basic.ll

 define i32 @test10a() nounwind {
 entry:
   %call = call i32 @test10b(i32 undef)
   ret i32 %call
 
 ; CHECK-LABEL: define i32 @test10a(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    %call = call i32 @test10b(i32 undef)
-; CHECK-NEXT:    ret i32 %call
+; CHECK-NEXT:    ret i32 undef
 }
 
 define internal i32 @test10b(i32 %x) nounwind {
 entry:
   %r = and i32 %x, 1
   ret i32 %r
 ; CHECK-LABEL: define internal i32 @test10b(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %r = and i32 undef, 1
-; CHECK-NEXT:    ret i32 %r
+; CHECK-NEXT:    ret i32 undef
 }
 
 ;;======================== test11
 
 define i64 @test11a() {
   %xor = xor i64 undef, undef
   ret i64 %xor
 ; CHECK-LABEL: define i64 @test11a

llvm/test/Transforms/SCCP/resolvedundefsin-tracked-fn.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; RUN: opt -ipsccp -S %s | FileCheck %s
 
 %t1 = type opaque
 
 @e = common global i32 0, align 4
 
 ; Test that we a skip unknown values depending on a unknown tracked call, until the call gets resolved. The @test1 and @test2 variants are very similar, they just check 2 different kinds of users (icmp and zext)
 
 define i32 @test1_m(i32 %h) {
-; CHECK-LABEL: define i32 @test1_m(
+; CHECK-LABEL: define {{[^@]+}}@test1_m
+; CHECK-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H:%.*]] to i8
+; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H]] to i8
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @test1_k(i8 [[CONV]], i32 0)
 ; CHECK-NEXT:    [[CONV1:%.*]] = sext i32 [[H]] to i64
 ; CHECK-NEXT:    [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
 ; CHECK-NEXT:    [[CALL2:%.*]] = call i1 @test1_g(%t1* [[TMP0]], i32 1)
 ; CHECK-NEXT:    ret i32 undef
 ;
 entry:
   %conv = trunc i32 %h to i8
   %call = call i32 @test1_k(i8 %conv, i32 0)
   %conv1 = sext i32 %h to i64
   %0 = inttoptr i64 %conv1 to %t1*
   %call2 = call i1 @test1_g(%t1* %0, i32 1)
   ret i32 undef
 
 ; uselistorder directives
   uselistorder i32 %h, { 1, 0 }
 }
 
 declare void @use.1(i1)
 
 define internal i32 @test1_k(i8 %h, i32 %i) {
-; CHECK-LABEL: define {{.*}} @test1_k(
+; CHECK-LABEL: define {{[^@]+}}@test1_k
+; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @e, align 4
 ; CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP0]] to i64
 ; CHECK-NEXT:    [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
 ; CHECK-NEXT:    [[CALL:%.*]] = call i1 @test1_g(%t1* [[TMP1]], i32 0)
-; CHECK-NEXT:    [[FROMBOOL_1:%.*]] = zext i1 false to i8
-; CHECK-NEXT:    [[TOBOOL_1:%.*]] = trunc i8 [[FROMBOOL_1]] to i1
-; CHECK-NEXT:    call void @use.1(i1 [[TOBOOL_1]])
+; CHECK-NEXT:    call void @use.1(i1 false)
 ; CHECK-NEXT:    ret i32 undef
 ;
 entry:
   %0 = load i32, i32* @e, align 4
   %conv = sext i32 %0 to i64
   %1 = inttoptr i64 %conv to %t1*
   %call = call i1 @test1_g(%t1* %1, i32 %i)
   %frombool.1 = zext i1 %call to i8
   %tobool.1 = trunc i8 %frombool.1 to i1
   call void @use.1(i1 %tobool.1)
   ret i32 undef
 }
 
 define internal i1 @test1_g(%t1* %h, i32 %i) #0 {
-; CHECK-LABEL: define {{.*}} @test1_g(
+; CHECK-LABEL: define {{[^@]+}}@test1_g
+; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[I:%.*]], 0
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[I]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
 ; CHECK:       land.rhs:
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 (...) @test1_j()
 ; CHECK-NEXT:    [[TOBOOL1:%.*]] = icmp ne i32 [[CALL]], 0
 ; CHECK-NEXT:    br label [[LAND_END]]
 ; CHECK:       land.end:
 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[TOBOOL1]], [[LAND_RHS]] ]
 ; CHECK-NEXT:    ret i1 undef

 land.end:                                         ; preds = %land.rhs, %entry
   %0 = phi i1 [ false, %entry ], [ %tobool1, %land.rhs ]
   ret i1 false
 }
 
 declare i32 @test1_j(...)
 
 define i32 @test2_m(i32 %h) #0 {
-; CHECK-LABEL: define {{.*}} @test2_m(
+; CHECK-LABEL: define {{[^@]+}}@test2_m
+; CHECK-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H:%.*]] to i8
+; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H]] to i8
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @test2_k(i8 [[CONV]], i32 0)
 ; CHECK-NEXT:    [[CONV1:%.*]] = sext i32 [[H]] to i64
 ; CHECK-NEXT:    [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
 ; CHECK-NEXT:    [[CALL2:%.*]] = call i1 @test2_g(%t1* [[TMP0]], i32 1)
 ; CHECK-NEXT:    ret i32 undef
 ;
 entry:
   %conv = trunc i32 %h to i8
   %call = call i32 @test2_k(i8 %conv, i32 0)
   %conv1 = sext i32 %h to i64
   %0 = inttoptr i64 %conv1 to %t1*
   %call2 = call i1 @test2_g(%t1* %0, i32 1)
   ret i32 undef
 
 ; uselistorder directives
   uselistorder i32 %h, { 1, 0 }
 }
 
 ; TODO: We could do better for the return value of call i1 @test3_g, if we
 ;       resolve the unknown values there first.
 define internal i32 @test2_k(i8 %h, i32 %i) {
-; CHECK-LABEL: define {{.*}} @test2_k(
+; CHECK-LABEL: define {{[^@]+}}@test2_k
+; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @e, align 4
 ; CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP0]] to i64
 ; CHECK-NEXT:    [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
 ; CHECK-NEXT:    [[CALL:%.*]] = call i1 @test3_g(%t1* [[TMP1]], i32 0)
-; CHECK-NEXT:    [[FROMBOOL:%.*]] = icmp slt i1 false, true
-; CHECK-NEXT:    [[ADD:%.*]] = add i1 [[FROMBOOL]], [[FROMBOOL]]
-; CHECK-NEXT:    call void @use.1(i1 [[FROMBOOL]])
+; CHECK-NEXT:    call void @use.1(i1 false)
 ; CHECK-NEXT:    ret i32 undef
 ;
 entry:
   %0 = load i32, i32* @e, align 4
   %conv = sext i32 %0 to i64
   %1 = inttoptr i64 %conv to %t1*
   %call = call i1 @test3_g(%t1* %1, i32 %i)
   %frombool = icmp slt i1 %call, 1
   %add = add i1 %frombool, %frombool
   call void @use.1(i1 %frombool)
   ret i32 undef
 
 }
 
 define internal i1 @test2_g(%t1* %h, i32 %i) {
-; CHECK-LABEL: define {{.*}} @test2_g(
+; CHECK-LABEL: define {{[^@]+}}@test2_g
+; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 true, label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
 ; CHECK:       land.rhs:
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 (...) @test2_j()
 ; CHECK-NEXT:    [[TOBOOL1:%.*]] = icmp ne i32 [[CALL]], 0
 ; CHECK-NEXT:    br label [[LAND_END]]
 ; CHECK:       land.end:
 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[TOBOOL1]], [[LAND_RHS]] ]

 }
 
 declare i32 @test2_j(...)
 
 
 
 ; Same as test_2*, but with a PHI node depending on a tracked  call result.
 define i32 @test3_m(i32 %h) #0 {
-; CHECK-LABEL: define {{.*}} @test3_m(
+; CHECK-LABEL: define {{[^@]+}}@test3_m
+; CHECK-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H:%.*]] to i8
+; CHECK-NEXT:    [[CONV:%.*]] = trunc i32 [[H]] to i8
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @test3_k(i8 [[CONV]], i32 0)
 ; CHECK-NEXT:    [[CONV1:%.*]] = sext i32 [[H]] to i64
 ; CHECK-NEXT:    [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
 ; CHECK-NEXT:    [[CALL2:%.*]] = call i1 @test3_g(%t1* [[TMP0]], i32 1)
 ; CHECK-NEXT:    ret i32 undef
 ;
 entry:
   %conv = trunc i32 %h to i8
   %call = call i32 @test3_k(i8 %conv, i32 0)
   %conv1 = sext i32 %h to i64
   %0 = inttoptr i64 %conv1 to %t1*
   %call2 = call i1 @test3_g(%t1* %0, i32 1)
   ret i32 undef
 
 ; uselistorder directives
   uselistorder i32 %h, { 1, 0 }
 }
 
 define internal i32 @test3_k(i8 %h, i32 %i) {
-; CHECK-LABEL: define {{.*}} @test3_k(
+; CHECK-LABEL: define {{[^@]+}}@test3_k
+; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @e, align 4
 ; CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP0]] to i64
 ; CHECK-NEXT:    [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[PHI:%.*]] = phi i1 [ undef, [[ENTRY:%.*]] ], [ false, [[LOOP]] ]
 ; CHECK-NEXT:    [[CALL:%.*]] = call i1 @test3_g(%t1* [[TMP1]], i32 0)
loop:
   call void @use.1(i1 %frombool)
   br i1 %call, label %loop, label %exit
 
 exit:
   ret i32 undef
 }
 
 define internal i1 @test3_g(%t1* %h, i32 %i) {
-; CHECK-LABEL: define {{.*}} @test3_g(
+; CHECK-LABEL: define {{[^@]+}}@test3_g
+; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[I:%.*]], 0
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[I]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
 ; CHECK:       land.rhs:
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 (...) @test3_j()
 ; CHECK-NEXT:    [[TOBOOL1:%.*]] = icmp ne i32 [[CALL]], 0
 ; CHECK-NEXT:    br label [[LAND_END]]
 ; CHECK:       land.end:
 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[TOBOOL1]], [[LAND_RHS]] ]
 ; CHECK-NEXT:    ret i1 undef

 
 ; TODO: We can eliminate the bitcast, if we resolve the unknown argument of
 ;       @test4_b first.
 
 declare void @use.16(i16*)
 declare void @use.8(i8*)
 
 define void @test4_a() {
-; CHECK-LABEL: define {{.*}} @test4_a(
+; CHECK-LABEL: define {{[^@]+}}@test4_a()
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = call i8* @test4_c(i8* null)
 ; CHECK-NEXT:    call void @test4_b(i8* null)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %tmp = call i8* @test4_c(i8* null)
   call void @test4_b(i8* %tmp)
   ret void
 }
 
 define internal void @test4_b(i8* %arg) {
-; CHECK-LABEL: define {{.*}} @test4_b(
+; CHECK-LABEL: define {{[^@]+}}@test4_b
+; CHECK-SAME: (i8* [[ARG:%.*]])
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[TMP:%.*]] = bitcast i8* null to i16*
-; CHECK-NEXT:    call void @use.16(i16* [[TMP]])
+; CHECK-NEXT:    call void @use.16(i16* null)
 ; CHECK-NEXT:    call void @use.8(i8* null)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %tmp = bitcast i8* %arg to i16*
   %sel = select i1 false, i8* %arg, i8* %arg
   call void @use.16(i16* %tmp)
   call void @use.8(i8* %sel)
   ret void
 }
 
 define internal i8* @test4_c(i8* %arg) {
-; CHECK-LABEL: define {{.*}} @test4_c(
+; CHECK-LABEL: define {{[^@]+}}@test4_c
+; CHECK-SAME: (i8* [[ARG:%.*]])
 ; CHECK-NEXT:  bb1:
 ; CHECK-NEXT:    [[TMP:%.*]] = and i1 undef, undef
 ; CHECK-NEXT:    br i1 [[TMP]], label [[BB3:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       bb3:
 ; CHECK-NEXT:    ret i8* undef
 ;
 bb1:                                              ; preds = %bb
   %tmp = and i1 undef, undef
   br i1 %tmp, label %bb3, label %bb2
 
 bb2:                                              ; preds = %bb1
   unreachable
 
 bb3:                                              ; preds = %bb1
   ret i8* null
 }
 
 ; TODO: Same as test4, but with a select instead of a bitcast.
 
 define void @test5_a() {
-; CHECK-LABEL: define {{.*}} @test5_a(
+; CHECK-LABEL: define {{[^@]+}}@test5_a()
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = call i8* @test5_c(i8* null)
 ; CHECK-NEXT:    call void @test5_b(i8* null)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %tmp = call i8* @test5_c(i8* null)
   call void @test5_b(i8* %tmp)
   ret void
 }
 
 define internal void @test5_b(i8* %arg) {
-; CHECK-LABEL: define {{.*}} @test5_b(
+; CHECK-LABEL: define {{[^@]+}}@test5_b
+; CHECK-SAME: (i8* [[ARG:%.*]])
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 false, i8* null, i8* null
-; CHECK-NEXT:    call void @use.8(i8* [[SEL]])
+; CHECK-NEXT:    call void @use.8(i8* null)
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %sel = select i1 false, i8* %arg, i8* %arg
   call void @use.8(i8* %sel)
   ret void
 }
 
 define internal i8* @test5_c(i8* %arg) {
-; CHECK-LABEL: define {{.*}} @test5_c(
+; CHECK-LABEL: define {{[^@]+}}@test5_c
+; CHECK-SAME: (i8* [[ARG:%.*]])
 ; CHECK-NEXT:  bb1:
 ; CHECK-NEXT:    [[TMP:%.*]] = and i1 undef, undef
 ; CHECK-NEXT:    br i1 [[TMP]], label [[BB3:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       bb3:
 ; CHECK-NEXT:    ret i8* undef
 ;

 
 
 
 @contextsize = external dso_local local_unnamed_addr global i32, align 4
 @pcount = internal local_unnamed_addr global i32 0, align 4
 @maxposslen = external dso_local local_unnamed_addr global i32, align 4
 
 define void @test3() {
-; CHECK-LABEL: define {{.*}} @test3(
+; CHECK-LABEL: define {{[^@]+}}@test3()
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[IF_END16:%.*]]
 ; CHECK:       if.end16:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @contextsize, align 4
 ; CHECK-NEXT:    [[SUB18:%.*]] = sub i32 undef, [[TMP0]]
 ; CHECK-NEXT:    [[SUB19:%.*]] = sub i32 [[SUB18]], undef
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @maxposslen, align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], 8