test/Transforms/DeadStoreElimination/multiblock-multipath.ll - llvm-project/llvm - Git at Google

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s

 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"

 declare void @use(i32 *)

 ; Tests where the pointer/object is accessible after the function returns.

 define void @accessible_after_return_1(i32* noalias %P, i1 %c1) {
 ; CHECK-LABEL: @accessible_after_return_1(
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br label %bb5
 bb2:
   store i32 3, i32* %P
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 define void @accessible_after_return_2(i32* noalias %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return_2(
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    store i32 5, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, i32* %P
   br i1 %c.1, label %bb1, label %bb2
 bb1:
   store i32 0, i32* %P
   br label %bb5

 bb2:
   br i1 %c.2, label %bb3, label %bb4

 bb3:
   store i32 3, i32* %P
   br label %bb5

 bb4:
   store i32 5, i32* %P
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 ; Cannot remove store in entry block because it is not overwritten on path
 ; entry->bb2->bb5.
 define void @accessible_after_return_3(i32* noalias %P, i1 %c1) {
 ; CHECK-LABEL: @accessible_after_return_3(
 ; CHECK-NEXT:    store i32 1, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br label %bb5

 bb2:
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 ; Cannot remove store in entry block because it is not overwritten on path
 ; entry->bb2->bb5.
 define void @accessible_after_return_4(i32* noalias %P, i1 %c1) {
 ; CHECK-LABEL: @accessible_after_return_4(
 ; CHECK-NEXT:    store i32 1, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   call void @use(i32* %P)
   br label %bb5

 bb2:
   br label %bb5

 bb5:
   ret void
 }

 ; Cannot remove the store in entry, as it is not overwritten on all paths to an
 ; exit (patch including bb4).
 define void @accessible_after_return5(i32* %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 0, i32* %P
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   br i1 %c.2, label %bb3, label %bb4

 bb2:
   store i32 1, i32* %P
   br label %bb5

 bb3:
   store i32 2, i32* %P
   br label %bb5

 bb4:
   br label %bb5

 bb5:
   ret void
 }

 ; Can remove store in entry block, because it is overwritten before each return.
 define void @accessible_after_return6(i32* %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 1, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb4:
 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 0, i32* %P
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   br i1 %c.2, label %bb3, label %bb4

 bb2:
   store i32 1, i32* %P
   ret void

 bb3:
   store i32 2, i32* %P
   ret void

 bb4:
   store i32 3, i32* %P
   ret void
 }

 ; Can remove store in bb1, because it is overwritten along each path
 ; from bb1 to the exit.
 define void @accessible_after_return7(i32* %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 2, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br i1 %c.2, label %bb3, label %bb4

 bb3:
   store i32 2, i32* %P
   br label %bb5

 bb4:
   store i32 1, i32* %P
   br label %bb5

 bb2:
   br label %bb5

 bb5:
   ret void
 }


 ; Cannot remove store in entry block, because it is overwritten along each path to
 ; the exit (entry->bb1->bb4->bb5).
 define void @accessible_after_return8(i32* %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 0, i32* %P
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   br i1 %c.2, label %bb3, label %bb4

 bb2:
   store i32 1, i32* %P
   br label %bb5

 bb3:
   store i32 2, i32* %P
   br label %bb5

 bb4:
   br label %bb5

 bb5:
   ret void
 }

 ; Make sure no stores are removed here. In particular, the store in if.then
 ; should not be removed.
 define void @accessible_after_return9(i8* noalias %ptr) {
 ; CHECK-LABEL: @accessible_after_return9(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C_0:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_0]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    store i8 99, i8* [[PTR:%.*]], align 8
 ; CHECK-NEXT:    [[C_1:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_1]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    store i8 20, i8* [[PTR]], align 8
 ; CHECK-NEXT:    br label [[IF_END]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[C_2:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_2]], label [[IF_THEN10:%.*]], label [[FOR_INC:%.*]]
 ; CHECK:       if.then10:
 ; CHECK-NEXT:    store i8 0, i8* [[PTR]], align 8
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       for.inc:
 ; CHECK-NEXT:    [[C_3:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_3]], label [[FOR_BODY]], label [[FOR_END]]
 ; CHECK:       for.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c.0 = call i1 @cond()
   br i1 %c.0, label %for.body, label %for.end

 for.body:
   store i8 99, i8* %ptr, align 8
   %c.1 = call i1 @cond()
   br i1 %c.1, label %if.end, label %if.then

 if.then:
   store i8 20, i8* %ptr, align 8
   br label %if.end

 if.end:
   %c.2 = call i1 @cond()
   br i1 %c.2, label %if.then10, label %for.inc

 if.then10:
   store i8 0, i8* %ptr, align 8
   br label %for.inc

 for.inc:
   %c.3 = call i1 @cond()
   br i1 %c.3, label %for.body, label %for.end

 for.end:
   ret void
 }

 ; Cannot remove store in entry block because it is not overwritten on path
 ; entry->bb2->bb4. Also make sure we deal with dead exit blocks without
 ; crashing.
 define void @accessible_after_return10_dead_block(i32* %P, i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @accessible_after_return10_dead_block(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb4:
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 0, i32* %P
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   br i1 %c.2, label %bb3, label %bb4

 bb2:
   store i32 1, i32* %P
   ret void

 bb3:
   store i32 2, i32* %P
   ret void

 bb4:
   ret void

 bb5:
   ret void
 }

 @linenum = external local_unnamed_addr global i32, align 4

 define void @accessible_after_return11_loop() {
 ; CHECK-LABEL: @accessible_after_return11_loop(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_BODY_I:%.*]]
 ; CHECK:       for.body.i:
 ; CHECK-NEXT:    [[C_1:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_1]], label [[FOR_BODY_I]], label [[INIT_PARSE_EXIT:%.*]]
 ; CHECK:       init_parse.exit:
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull undef)
 ; CHECK-NEXT:    store i32 0, i32* @linenum, align 4
 ; CHECK-NEXT:    br label [[FOR_BODY_I20:%.*]]
 ; CHECK:       for.body.i20:
 ; CHECK-NEXT:    [[C_2:%.*]] = call i1 @cond()
 ; CHECK-NEXT:    br i1 [[C_2]], label [[FOR_BODY_I20]], label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %for.body.i

 for.body.i:                                       ; preds = %for.body.i, %entry
   %c.1 = call i1 @cond()
   br i1 %c.1, label %for.body.i, label %init_parse.exit

 init_parse.exit:                                  ; preds = %for.body.i
   store i32 0, i32* @linenum, align 4
   call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull undef) #2
   store i32 0, i32* @linenum, align 4
   br label %for.body.i20

 for.body.i20:                                     ; preds = %for.body.i20, %init_parse.exit
   %c.2 = call i1 @cond()
   br i1 %c.2, label %for.body.i20, label %exit

 exit:
   ret void
 }
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
 declare i1 @cond() readnone nounwind

 ; Tests where the pointer/object is *NOT* accessible after the function returns.

 ; The store in the entry block can be eliminated, because it is overwritten
 ; on all paths to the exit.
 define void @alloca_1(i1 %c1) {
 ; CHECK-LABEL: @alloca_1(
 ; CHECK-NEXT:    [[P:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   %P = alloca i32
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br label %bb5
 bb2:
   store i32 3, i32* %P
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 ; The store in the entry block can be eliminated, because it is overwritten
 ; on all paths to the exit.
 define void @alloca_2(i1 %c.1, i1 %c.2) {
 ; CHECK-LABEL: @alloca_2(
 ; CHECK-NEXT:    [[P:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br i1 [[C_2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    store i32 5, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   %P = alloca i32
   store i32 1, i32* %P
   br i1 %c.1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br label %bb5

 bb2:
   br i1 %c.2, label %bb3, label %bb4

 bb3:
   store i32 3, i32* %P
   br label %bb5

 bb4:
   store i32 5, i32* %P
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 ; The store in the entry block cannot be eliminated. There's a path from the
 ; first store to the read in bb5, where the location is not overwritten.
 define void @alloca_3(i1 %c1) {
 ; CHECK-LABEL: @alloca_3(
 ; CHECK-NEXT:    [[P:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    ret void
 ;
   %P = alloca i32
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   br label %bb5
 bb2:
   br label %bb5

 bb5:
   call void @use(i32* %P)
   ret void
 }

 ; The store in the entry block can be eliminated, because it is overwritten
 ; before the use in bb1 and not read on other paths to the function exit. The
 ; object cannot be accessed by the caller.
 define void @alloca_4(i1 %c1) {
 ; CHECK-LABEL: @alloca_4(
 ; CHECK-NEXT:    [[P:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    call void @use(i32* [[P]])
 ; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[BB5]]
 ; CHECK:       bb5:
 ; CHECK-NEXT:    ret void
 ;
   %P = alloca i32
   store i32 1, i32* %P
   br i1 %c1, label %bb1, label %bb2

 bb1:
   store i32 0, i32* %P
   call void @use(i32* %P)
   br label %bb5

 bb2:
   br label %bb5

 bb5:
   ret void
 }

 %struct.blam.4 = type { %struct.bar.5, [4 x i8] }
 %struct.bar.5 = type <{ i64, i64*, i32, i64 }>

 ; Make sure we do not eliminate the store in %bb.
 define void @alloca_5(i1 %c) {
 ; CHECK-LABEL: @alloca_5(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = alloca [[STRUCT_BLAM_4:%.*]], align 8
 ; CHECK-NEXT:    [[TMP38:%.*]] = getelementptr inbounds [[STRUCT_BLAM_4]], %struct.blam.4* [[TMP]], i64 0, i32 0, i32 3
 ; CHECK-NEXT:    [[TMP39:%.*]] = bitcast i64* [[TMP38]] to i64*
 ; CHECK-NEXT:    store i64 0, i64* [[TMP39]], align 4
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB46:%.*]], label [[BB47:%.*]]
 ; CHECK:       bb46:
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb47:
 ; CHECK-NEXT:    [[TMP48:%.*]] = getelementptr inbounds [[STRUCT_BLAM_4]], %struct.blam.4* [[TMP]], i64 0, i32 0, i32 2
 ; CHECK-NEXT:    store i32 20, i32* [[TMP48]], align 8
 ; CHECK-NEXT:    br label [[BB52:%.*]]
 ; CHECK:       bb52:
 ; CHECK-NEXT:    br i1 [[C]], label [[BB68:%.*]], label [[BB59:%.*]]
 ; CHECK:       bb59:
 ; CHECK-NEXT:    call void @use.2(%struct.blam.4* [[TMP]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb68:
 ; CHECK-NEXT:    ret void
 ;
 bb:
   %tmp = alloca %struct.blam.4, align 8
   %tmp36 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 1
   %tmp37 = bitcast i64** %tmp36 to i8*
   %tmp38 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 3
   %tmp39 = bitcast i64* %tmp38 to i64*
   store i64 0, i64* %tmp39, align 4
   br i1 %c, label %bb46, label %bb47

 bb46:                                             ; preds = %bb12
   call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(20) %tmp37, i8 0, i64 26, i1 false)
   ret void

 bb47:                                             ; preds = %bb12
   %tmp48 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 2
   store i32 20, i32* %tmp48, align 8
   br label %bb52

 bb52:                                             ; preds = %bb47
   br i1 %c, label %bb68, label %bb59

 bb59:                                             ; preds = %bb52
   call void @use.2(%struct.blam.4* %tmp)
   ret void

 bb68:                                             ; preds = %bb52
   ret void
 }

 declare void @use.2(%struct.blam.4*)

 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)
	; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
	; RUN: opt < %s -basic-aa -dse -S \| FileCheck %s

	target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"

	declare void @use(i32 *)

	; Tests where the pointer/object is accessible after the function returns.

	define void @accessible_after_return_1(i32* noalias %P, i1 %c1) {
	; CHECK-LABEL: @accessible_after_return_1(
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 3, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br label %bb5
	bb2:
	store i32 3, i32* %P
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	define void @accessible_after_return_2(i32* noalias %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return_2(
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb3:
	; CHECK-NEXT: store i32 3, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb4:
	; CHECK-NEXT: store i32 5, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	store i32 1, i32* %P
	br i1 %c.1, label %bb1, label %bb2
	bb1:
	store i32 0, i32* %P
	br label %bb5

	bb2:
	br i1 %c.2, label %bb3, label %bb4

	bb3:
	store i32 3, i32* %P
	br label %bb5

	bb4:
	store i32 5, i32* %P
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	; Cannot remove store in entry block because it is not overwritten on path
	; entry->bb2->bb5.
	define void @accessible_after_return_3(i32* noalias %P, i1 %c1) {
	; CHECK-LABEL: @accessible_after_return_3(
	; CHECK-NEXT: store i32 1, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br label %bb5

	bb2:
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	; Cannot remove store in entry block because it is not overwritten on path
	; entry->bb2->bb5.
	define void @accessible_after_return_4(i32* noalias %P, i1 %c1) {
	; CHECK-LABEL: @accessible_after_return_4(
	; CHECK-NEXT: store i32 1, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	call void @use(i32* %P)
	br label %bb5

	bb2:
	br label %bb5

	bb5:
	ret void
	}

	; Cannot remove the store in entry, as it is not overwritten on all paths to an
	; exit (patch including bb4).
	define void @accessible_after_return5(i32* %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return5(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 1, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb3:
	; CHECK-NEXT: store i32 2, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb4:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	entry:
	store i32 0, i32* %P
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	br i1 %c.2, label %bb3, label %bb4

	bb2:
	store i32 1, i32* %P
	br label %bb5

	bb3:
	store i32 2, i32* %P
	br label %bb5

	bb4:
	br label %bb5

	bb5:
	ret void
	}

	; Can remove store in entry block, because it is overwritten before each return.
	define void @accessible_after_return6(i32* %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return6(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 1, i32* [[P:%.*]], align 4
	; CHECK-NEXT: ret void
	; CHECK: bb3:
	; CHECK-NEXT: store i32 2, i32* [[P]], align 4
	; CHECK-NEXT: ret void
	; CHECK: bb4:
	; CHECK-NEXT: store i32 3, i32* [[P]], align 4
	; CHECK-NEXT: ret void
	;
	entry:
	store i32 0, i32* %P
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	br i1 %c.2, label %bb3, label %bb4

	bb2:
	store i32 1, i32* %P
	ret void

	bb3:
	store i32 2, i32* %P
	ret void

	bb4:
	store i32 3, i32* %P
	ret void
	}

	; Can remove store in bb1, because it is overwritten along each path
	; from bb1 to the exit.
	define void @accessible_after_return7(i32* %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return7(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb3:
	; CHECK-NEXT: store i32 2, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb4:
	; CHECK-NEXT: store i32 1, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb2:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	entry:
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br i1 %c.2, label %bb3, label %bb4

	bb3:
	store i32 2, i32* %P
	br label %bb5

	bb4:
	store i32 1, i32* %P
	br label %bb5

	bb2:
	br label %bb5

	bb5:
	ret void
	}


	; Cannot remove store in entry block, because it is overwritten along each path to
	; the exit (entry->bb1->bb4->bb5).
	define void @accessible_after_return8(i32* %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return8(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 1, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb3:
	; CHECK-NEXT: store i32 2, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb4:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	entry:
	store i32 0, i32* %P
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	br i1 %c.2, label %bb3, label %bb4

	bb2:
	store i32 1, i32* %P
	br label %bb5

	bb3:
	store i32 2, i32* %P
	br label %bb5

	bb4:
	br label %bb5

	bb5:
	ret void
	}

	; Make sure no stores are removed here. In particular, the store in if.then
	; should not be removed.
	define void @accessible_after_return9(i8* noalias %ptr) {
	; CHECK-LABEL: @accessible_after_return9(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: [[C_0:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_0]], label [[FOR_BODY:%.]], label [[FOR_END:%.]]
	; CHECK: for.body:
	; CHECK-NEXT: store i8 99, i8* [[PTR:%.*]], align 8
	; CHECK-NEXT: [[C_1:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_1]], label [[IF_END:%.]], label [[IF_THEN:%.]]
	; CHECK: if.then:
	; CHECK-NEXT: store i8 20, i8* [[PTR]], align 8
	; CHECK-NEXT: br label [[IF_END]]
	; CHECK: if.end:
	; CHECK-NEXT: [[C_2:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_2]], label [[IF_THEN10:%.]], label [[FOR_INC:%.]]
	; CHECK: if.then10:
	; CHECK-NEXT: store i8 0, i8* [[PTR]], align 8
	; CHECK-NEXT: br label [[FOR_INC]]
	; CHECK: for.inc:
	; CHECK-NEXT: [[C_3:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_3]], label [[FOR_BODY]], label [[FOR_END]]
	; CHECK: for.end:
	; CHECK-NEXT: ret void
	;
	entry:
	%c.0 = call i1 @cond()
	br i1 %c.0, label %for.body, label %for.end

	for.body:
	store i8 99, i8* %ptr, align 8
	%c.1 = call i1 @cond()
	br i1 %c.1, label %if.end, label %if.then

	if.then:
	store i8 20, i8* %ptr, align 8
	br label %if.end

	if.end:
	%c.2 = call i1 @cond()
	br i1 %c.2, label %if.then10, label %for.inc

	if.then10:
	store i8 0, i8* %ptr, align 8
	br label %for.inc

	for.inc:
	%c.3 = call i1 @cond()
	br i1 %c.3, label %for.body, label %for.end

	for.end:
	ret void
	}

	; Cannot remove store in entry block because it is not overwritten on path
	; entry->bb2->bb4. Also make sure we deal with dead exit blocks without
	; crashing.
	define void @accessible_after_return10_dead_block(i32* %P, i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @accessible_after_return10_dead_block(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 1, i32* [[P]], align 4
	; CHECK-NEXT: ret void
	; CHECK: bb3:
	; CHECK-NEXT: store i32 2, i32* [[P]], align 4
	; CHECK-NEXT: ret void
	; CHECK: bb4:
	; CHECK-NEXT: ret void
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	entry:
	store i32 0, i32* %P
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	br i1 %c.2, label %bb3, label %bb4

	bb2:
	store i32 1, i32* %P
	ret void

	bb3:
	store i32 2, i32* %P
	ret void

	bb4:
	ret void

	bb5:
	ret void
	}

	@linenum = external local_unnamed_addr global i32, align 4

	define void @accessible_after_return11_loop() {
	; CHECK-LABEL: @accessible_after_return11_loop(
	; CHECK-NEXT: entry:
	; CHECK-NEXT: br label [[FOR_BODY_I:%.*]]
	; CHECK: for.body.i:
	; CHECK-NEXT: [[C_1:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_1]], label [[FOR_BODY_I]], label [[INIT_PARSE_EXIT:%.*]]
	; CHECK: init_parse.exit:
	; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull undef)
	; CHECK-NEXT: store i32 0, i32* @linenum, align 4
	; CHECK-NEXT: br label [[FOR_BODY_I20:%.*]]
	; CHECK: for.body.i20:
	; CHECK-NEXT: [[C_2:%.*]] = call i1 @cond()
	; CHECK-NEXT: br i1 [[C_2]], label [[FOR_BODY_I20]], label [[EXIT:%.*]]
	; CHECK: exit:
	; CHECK-NEXT: ret void
	;
	entry:
	br label %for.body.i

	for.body.i: ; preds = %for.body.i, %entry
	%c.1 = call i1 @cond()
	br i1 %c.1, label %for.body.i, label %init_parse.exit

	init_parse.exit: ; preds = %for.body.i
	store i32 0, i32* @linenum, align 4
	call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull undef) #2
	store i32 0, i32* @linenum, align 4
	br label %for.body.i20

	for.body.i20: ; preds = %for.body.i20, %init_parse.exit
	%c.2 = call i1 @cond()
	br i1 %c.2, label %for.body.i20, label %exit

	exit:
	ret void
	}
	declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
	declare i1 @cond() readnone nounwind

	; Tests where the pointer/object is NOT accessible after the function returns.

	; The store in the entry block can be eliminated, because it is overwritten
	; on all paths to the exit.
	define void @alloca_1(i1 %c1) {
	; CHECK-LABEL: @alloca_1(
	; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: store i32 3, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	%P = alloca i32
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br label %bb5
	bb2:
	store i32 3, i32* %P
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	; The store in the entry block can be eliminated, because it is overwritten
	; on all paths to the exit.
	define void @alloca_2(i1 %c.1, i1 %c.2) {
	; CHECK-LABEL: @alloca_2(
	; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
	; CHECK-NEXT: br i1 [[C_1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br i1 [[C_2:%.]], label [[BB3:%.]], label [[BB4:%.*]]
	; CHECK: bb3:
	; CHECK-NEXT: store i32 3, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb4:
	; CHECK-NEXT: store i32 5, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	%P = alloca i32
	store i32 1, i32* %P
	br i1 %c.1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br label %bb5

	bb2:
	br i1 %c.2, label %bb3, label %bb4

	bb3:
	store i32 3, i32* %P
	br label %bb5

	bb4:
	store i32 5, i32* %P
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	; The store in the entry block cannot be eliminated. There's a path from the
	; first store to the read in bb5, where the location is not overwritten.
	define void @alloca_3(i1 %c1) {
	; CHECK-LABEL: @alloca_3(
	; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
	; CHECK-NEXT: store i32 1, i32* [[P]], align 4
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: ret void
	;
	%P = alloca i32
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	br label %bb5
	bb2:
	br label %bb5

	bb5:
	call void @use(i32* %P)
	ret void
	}

	; The store in the entry block can be eliminated, because it is overwritten
	; before the use in bb1 and not read on other paths to the function exit. The
	; object cannot be accessed by the caller.
	define void @alloca_4(i1 %c1) {
	; CHECK-LABEL: @alloca_4(
	; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
	; CHECK-NEXT: br i1 [[C1:%.]], label [[BB1:%.]], label [[BB2:%.*]]
	; CHECK: bb1:
	; CHECK-NEXT: store i32 0, i32* [[P]], align 4
	; CHECK-NEXT: call void @use(i32* [[P]])
	; CHECK-NEXT: br label [[BB5:%.*]]
	; CHECK: bb2:
	; CHECK-NEXT: br label [[BB5]]
	; CHECK: bb5:
	; CHECK-NEXT: ret void
	;
	%P = alloca i32
	store i32 1, i32* %P
	br i1 %c1, label %bb1, label %bb2

	bb1:
	store i32 0, i32* %P
	call void @use(i32* %P)
	br label %bb5

	bb2:
	br label %bb5

	bb5:
	ret void
	}

	%struct.blam.4 = type { %struct.bar.5, [4 x i8] }
	%struct.bar.5 = type <{ i64, i64*, i32, i64 }>

	; Make sure we do not eliminate the store in %bb.
	define void @alloca_5(i1 %c) {
	; CHECK-LABEL: @alloca_5(
	; CHECK-NEXT: bb:
	; CHECK-NEXT: [[TMP:%.]] = alloca [[STRUCT_BLAM_4:%.]], align 8
	; CHECK-NEXT: [[TMP38:%.]] = getelementptr inbounds [[STRUCT_BLAM_4]], %struct.blam.4 [[TMP]], i64 0, i32 0, i32 3
	; CHECK-NEXT: [[TMP39:%.]] = bitcast i64 [[TMP38]] to i64*
	; CHECK-NEXT: store i64 0, i64* [[TMP39]], align 4
	; CHECK-NEXT: br i1 [[C:%.]], label [[BB46:%.]], label [[BB47:%.*]]
	; CHECK: bb46:
	; CHECK-NEXT: ret void
	; CHECK: bb47:
	; CHECK-NEXT: [[TMP48:%.]] = getelementptr inbounds [[STRUCT_BLAM_4]], %struct.blam.4 [[TMP]], i64 0, i32 0, i32 2
	; CHECK-NEXT: store i32 20, i32* [[TMP48]], align 8
	; CHECK-NEXT: br label [[BB52:%.*]]
	; CHECK: bb52:
	; CHECK-NEXT: br i1 [[C]], label [[BB68:%.]], label [[BB59:%.]]
	; CHECK: bb59:
	; CHECK-NEXT: call void @use.2(%struct.blam.4* [[TMP]])
	; CHECK-NEXT: ret void
	; CHECK: bb68:
	; CHECK-NEXT: ret void
	;
	bb:
	%tmp = alloca %struct.blam.4, align 8
	%tmp36 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 1
	%tmp37 = bitcast i64** %tmp36 to i8*
	%tmp38 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 3
	%tmp39 = bitcast i64* %tmp38 to i64*
	store i64 0, i64* %tmp39, align 4
	br i1 %c, label %bb46, label %bb47

	bb46: ; preds = %bb12
	call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(20) %tmp37, i8 0, i64 26, i1 false)
	ret void

	bb47: ; preds = %bb12
	%tmp48 = getelementptr inbounds %struct.blam.4, %struct.blam.4* %tmp, i64 0, i32 0, i32 2
	store i32 20, i32* %tmp48, align 8
	br label %bb52

	bb52: ; preds = %bb47
	br i1 %c, label %bb68, label %bb59

	bb59: ; preds = %bb52
	call void @use.2(%struct.blam.4* %tmp)
	ret void

	bb68: ; preds = %bb52
	ret void
	}

	declare void @use.2(%struct.blam.4*)

	declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)