test/Transforms/SCCP/resolvedundefsin-tracked-fn.ll - llvm-project/llvm - Git at Google

 ; 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 {{[^@]+}}@test1_m
 ; CHECK-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
 ; 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-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:    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-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; 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
 ;
 entry:
   %tobool = icmp ne i32 %i, 0
   br i1 %tobool, label %land.rhs, label %land.end

 land.rhs:                                         ; preds = %entry
   %call = call i32 (...) @test1_j()
   %tobool1 = icmp ne i32 %call, 0
   br label %land.end

 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-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
 ; 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-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:    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-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LAND_RHS:%.*]]
 ; 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:    ret i1 undef
 ;
 entry:
   %tobool = icmp ne i32 %i, 0
   br i1 %tobool, label %land.rhs, label %land.end

 land.rhs:                                         ; preds = %entry
   %call = call i32 (...) @test2_j()
   %tobool1 = icmp ne i32 %call, 0
   br label %land.end

 land.end:                                         ; preds = %land.rhs, %entry
   %0 = phi i1 [ false, %entry ], [ %tobool1, %land.rhs ]
   ret i1 false
 }

 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-SAME: (i32 [[H:%.*]])
 ; CHECK-NEXT:  entry:
 ; 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-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:    [[CALL:%.*]] = call i1 @test3_g(%t1* [[TMP1]], i32 0)
 ; CHECK-NEXT:    call void @use.1(i1 false)
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; 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*
   br label %loop

 loop:
   %phi = phi i1 [ undef, %entry], [ %call, %loop ]
   %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)
   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-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
 ; CHECK-NEXT:  entry:
 ; 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
 ;
 entry:
   %tobool = icmp ne i32 %i, 0
   br i1 %tobool, label %land.rhs, label %land.end

 land.rhs:                                         ; preds = %entry
   %call = call i32 (...) @test3_j()
   %tobool1 = icmp ne i32 %call, 0
   br label %land.end

 land.end:                                         ; preds = %land.rhs, %entry
   %0 = phi i1 [ false, %entry ], [ %tobool1, %land.rhs ]
   ret i1 false
 }

 declare i32 @test3_j(...)


 ; 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-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-SAME: (i8* [[ARG:%.*]])
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast i8* null to i16*
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 false, i8* null, i8* null
 ; CHECK-NEXT:    call void @use.16(i16* [[TMP]])
 ; CHECK-NEXT:    call void @use.8(i8* [[SEL]])
 ; 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-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-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-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:    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-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
 }


 @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-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
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 undef, [[ADD]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* @pcount, align 4
 ; CHECK-NEXT:    [[MUL:%.*]] = mul nsw i32 [[DIV]], [[SUB19]]
 ; CHECK-NEXT:    [[CMP20:%.*]] = icmp sgt i32 [[TMP2]], [[MUL]]
 ; CHECK-NEXT:    br i1 [[CMP20]], label [[IF_THEN22:%.*]], label [[IF_END24:%.*]]
 ; CHECK:       if.then22:
 ; CHECK-NEXT:    store i32 [[MUL]], i32* @pcount, align 4
 ; CHECK-NEXT:    ret void
 ; CHECK:       if.end24:
 ; CHECK-NEXT:    [[CMP25474:%.*]] = icmp sgt i32 [[TMP2]], 0
 ; CHECK-NEXT:    br i1 [[CMP25474]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    ret void
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %if.end16

 if.end16:                                         ; preds = %entry
   %0 = load i32, i32* @contextsize, align 4
   %sub18 = sub i32 undef, %0
   %sub19 = sub i32 %sub18, undef
   %1 = load i32, i32* @maxposslen, align 4
   %add = add nsw i32 %1, 8
   %div = sdiv i32 undef, %add
   %2 = load i32, i32* @pcount, align 4
   %mul = mul nsw i32 %div, %sub19
   %cmp20 = icmp sgt i32 %2, %mul
   br i1 %cmp20, label %if.then22, label %if.end24

 if.then22:                                        ; preds = %if.end16
   store i32 %mul, i32* @pcount, align 4
   ret void

 if.end24:                                         ; preds = %if.end16
   %cmp25474 = icmp sgt i32 %2, 0
   br i1 %cmp25474, label %for.body, label %for.end

 for.body:                                         ; preds = %if.end24
   %3 = trunc i64 0 to i32
   %div30 = sdiv i32 %3, %sub19
   ret void

 for.end:                                          ; preds = %if.end24
   ret void
 }
	; 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 {{[^@]+}}@test1_m
	; CHECK-SAME: (i32 [[H:%.*]])
	; CHECK-NEXT: entry:
	; 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-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: 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-SAME: (%t1* [[H:%.]], i32 [[I:%.]])
	; CHECK-NEXT: entry:
	; 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
	;
	entry:
	%tobool = icmp ne i32 %i, 0
	br i1 %tobool, label %land.rhs, label %land.end

	land.rhs: ; preds = %entry
	%call = call i32 (...) @test1_j()
	%tobool1 = icmp ne i32 %call, 0
	br label %land.end

	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-SAME: (i32 [[H:%.*]])
	; CHECK-NEXT: entry:
	; 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-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: 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-SAME: (%t1* [[H:%.]], i32 [[I:%.]])
	; CHECK-NEXT: entry:
	; CHECK-NEXT: br label [[LAND_RHS:%.*]]
	; 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: ret i1 undef
	;
	entry:
	%tobool = icmp ne i32 %i, 0
	br i1 %tobool, label %land.rhs, label %land.end

	land.rhs: ; preds = %entry
	%call = call i32 (...) @test2_j()
	%tobool1 = icmp ne i32 %call, 0
	br label %land.end

	land.end: ; preds = %land.rhs, %entry
	%0 = phi i1 [ false, %entry ], [ %tobool1, %land.rhs ]
	ret i1 false
	}

	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-SAME: (i32 [[H:%.*]])
	; CHECK-NEXT: entry:
	; 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-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: [[CALL:%.]] = call i1 @test3_g(%t1 [[TMP1]], i32 0)
	; CHECK-NEXT: call void @use.1(i1 false)
	; CHECK-NEXT: br label [[EXIT:%.*]]
	; CHECK: exit:
	; 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*
	br label %loop

	loop:
	%phi = phi i1 [ undef, %entry], [ %call, %loop ]
	%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)
	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-SAME: (%t1* [[H:%.]], i32 [[I:%.]])
	; CHECK-NEXT: entry:
	; 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
	;
	entry:
	%tobool = icmp ne i32 %i, 0
	br i1 %tobool, label %land.rhs, label %land.end

	land.rhs: ; preds = %entry
	%call = call i32 (...) @test3_j()
	%tobool1 = icmp ne i32 %call, 0
	br label %land.end

	land.end: ; preds = %land.rhs, %entry
	%0 = phi i1 [ false, %entry ], [ %tobool1, %land.rhs ]
	ret i1 false
	}

	declare i32 @test3_j(...)


	; 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-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-SAME: (i8* [[ARG:%.*]])
	; CHECK-NEXT: bb:
	; CHECK-NEXT: [[TMP:%.]] = bitcast i8 null to i16*
	; CHECK-NEXT: [[SEL:%.]] = select i1 false, i8 null, i8* null
	; CHECK-NEXT: call void @use.16(i16* [[TMP]])
	; CHECK-NEXT: call void @use.8(i8* [[SEL]])
	; 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-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-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-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: 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-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
	}



	@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-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
	; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 undef, [[ADD]]
	; CHECK-NEXT: [[TMP2:%.]] = load i32, i32 @pcount, align 4
	; CHECK-NEXT: [[MUL:%.*]] = mul nsw i32 [[DIV]], [[SUB19]]
	; CHECK-NEXT: [[CMP20:%.*]] = icmp sgt i32 [[TMP2]], [[MUL]]
	; CHECK-NEXT: br i1 [[CMP20]], label [[IF_THEN22:%.]], label [[IF_END24:%.]]
	; CHECK: if.then22:
	; CHECK-NEXT: store i32 [[MUL]], i32* @pcount, align 4
	; CHECK-NEXT: ret void
	; CHECK: if.end24:
	; CHECK-NEXT: [[CMP25474:%.*]] = icmp sgt i32 [[TMP2]], 0
	; CHECK-NEXT: br i1 [[CMP25474]], label [[FOR_BODY:%.]], label [[FOR_END:%.]]
	; CHECK: for.body:
	; CHECK-NEXT: ret void
	; CHECK: for.end:
	; CHECK-NEXT: ret void
	;
	entry:
	br label %if.end16

	if.end16: ; preds = %entry
	%0 = load i32, i32* @contextsize, align 4
	%sub18 = sub i32 undef, %0
	%sub19 = sub i32 %sub18, undef
	%1 = load i32, i32* @maxposslen, align 4
	%add = add nsw i32 %1, 8
	%div = sdiv i32 undef, %add
	%2 = load i32, i32* @pcount, align 4
	%mul = mul nsw i32 %div, %sub19
	%cmp20 = icmp sgt i32 %2, %mul
	br i1 %cmp20, label %if.then22, label %if.end24

	if.then22: ; preds = %if.end16
	store i32 %mul, i32* @pcount, align 4
	ret void

	if.end24: ; preds = %if.end16
	%cmp25474 = icmp sgt i32 %2, 0
	br i1 %cmp25474, label %for.body, label %for.end

	for.body: ; preds = %if.end24
	%3 = trunc i64 0 to i32
	%div30 = sdiv i32 %3, %sub19
	ret void

	for.end: ; preds = %if.end24
	ret void
	}