1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt -mtriple=thumbv8.1m.main-arm-eabihf -mattr=+mve.fp \ 3; RUN: -tail-predication=enabled -loop-vectorize -S < %s | \ 4; RUN: FileCheck %s 5 6define void @trunc_not_allowed_different_vec_elemns(i32* noalias nocapture %A, i32* noalias nocapture readonly %B, i32* noalias nocapture readonly %C, i16* noalias nocapture %D) #0 { 7; CHECK-LABEL: @trunc_not_allowed_different_vec_elemns( 8; CHECK-NEXT: entry: 9; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 10; CHECK: vector.ph: 11; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 12; CHECK: vector.body: 13; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 14; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 15; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[TMP0]] 16; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 17; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 18; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 19; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i32 [[TMP0]] 20; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, i32* [[TMP4]], i32 0 21; CHECK-NEXT: [[TMP6:%.*]] = bitcast i32* [[TMP5]] to <4 x i32>* 22; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP6]], align 4 23; CHECK-NEXT: [[TMP7:%.*]] = add nsw <4 x i32> [[WIDE_LOAD1]], [[WIDE_LOAD]] 24; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[TMP0]] 25; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP8]], i32 0 26; CHECK-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP9]] to <4 x i32>* 27; CHECK-NEXT: store <4 x i32> [[TMP7]], <4 x i32>* [[TMP10]], align 4 28; CHECK-NEXT: [[TMP11:%.*]] = trunc <4 x i32> [[TMP7]] to <4 x i16> 29; CHECK-NEXT: [[TMP12:%.*]] = shl <4 x i16> [[TMP11]], <i16 1, i16 1, i16 1, i16 1> 30; CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds i16, i16* [[D:%.*]], i32 [[TMP0]] 31; CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds i16, i16* [[TMP13]], i32 0 32; CHECK-NEXT: [[TMP15:%.*]] = bitcast i16* [[TMP14]] to <4 x i16>* 33; CHECK-NEXT: store <4 x i16> [[TMP12]], <4 x i16>* [[TMP15]], align 2 34; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 35; CHECK-NEXT: [[TMP16:%.*]] = icmp eq i32 [[INDEX_NEXT]], 428 36; CHECK-NEXT: br i1 [[TMP16]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP0:!llvm.loop !.*]] 37; CHECK: middle.block: 38; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 428 39; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 40; CHECK: scalar.ph: 41; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 428, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ] 42; CHECK-NEXT: br label [[FOR_BODY:%.*]] 43; CHECK: for.cond.cleanup: 44; CHECK-NEXT: ret void 45; CHECK: for.body: 46; CHECK-NEXT: [[I_021:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD9:%.*]], [[FOR_BODY]] ] 47; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[I_021]] 48; CHECK-NEXT: [[TMP17:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 49; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, i32* [[C]], i32 [[I_021]] 50; CHECK-NEXT: [[TMP18:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4 51; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP18]], [[TMP17]] 52; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[I_021]] 53; CHECK-NEXT: store i32 [[ADD]], i32* [[ARRAYIDX2]], align 4 54; CHECK-NEXT: [[ADD_TR:%.*]] = trunc i32 [[ADD]] to i16 55; CHECK-NEXT: [[CONV7:%.*]] = shl i16 [[ADD_TR]], 1 56; CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds i16, i16* [[D]], i32 [[I_021]] 57; CHECK-NEXT: store i16 [[CONV7]], i16* [[ARRAYIDX8]], align 2 58; CHECK-NEXT: [[ADD9]] = add nuw nsw i32 [[I_021]], 1 59; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD9]], 431 60; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP2:!llvm.loop !.*]] 61; 62entry: 63 br label %for.body 64 65for.cond.cleanup: 66 ret void 67 68for.body: 69 %i.021 = phi i32 [ 0, %entry ], [ %add9, %for.body ] 70 %arrayidx = getelementptr inbounds i32, i32* %B, i32 %i.021 71 %0 = load i32, i32* %arrayidx, align 4 72 %arrayidx1 = getelementptr inbounds i32, i32* %C, i32 %i.021 73 %1 = load i32, i32* %arrayidx1, align 4 74 %add = add nsw i32 %1, %0 75 %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %i.021 76 store i32 %add, i32* %arrayidx2, align 4 77 %add.tr = trunc i32 %add to i16 78 %conv7 = shl i16 %add.tr, 1 79 %arrayidx8 = getelementptr inbounds i16, i16* %D, i32 %i.021 80 store i16 %conv7, i16* %arrayidx8, align 2 81 %add9 = add nuw nsw i32 %i.021, 1 82 %exitcond = icmp eq i32 %add9, 431 83 br i1 %exitcond, label %for.cond.cleanup, label %for.body 84} 85 86define void @unsupported_i64_type(i64* noalias nocapture %A, i64* noalias nocapture readonly %B, i64* noalias nocapture readonly %C) #0 { 87; CHECK-LABEL: @unsupported_i64_type( 88; CHECK-NEXT: entry: 89; CHECK-NEXT: br label [[FOR_BODY:%.*]] 90; CHECK: for.cond.cleanup: 91; CHECK-NEXT: ret void 92; CHECK: for.body: 93; CHECK-NEXT: [[I_09:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[ADD3:%.*]], [[FOR_BODY]] ] 94; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i64, i64* [[B:%.*]], i32 [[I_09]] 95; CHECK-NEXT: [[TMP0:%.*]] = load i64, i64* [[ARRAYIDX]], align 8 96; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i64, i64* [[C:%.*]], i32 [[I_09]] 97; CHECK-NEXT: [[TMP1:%.*]] = load i64, i64* [[ARRAYIDX1]], align 8 98; CHECK-NEXT: [[ADD:%.*]] = add nsw i64 [[TMP1]], [[TMP0]] 99; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i64, i64* [[A:%.*]], i32 [[I_09]] 100; CHECK-NEXT: store i64 [[ADD]], i64* [[ARRAYIDX2]], align 8 101; CHECK-NEXT: [[ADD3]] = add nuw nsw i32 [[I_09]], 1 102; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD3]], 431 103; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]] 104; 105entry: 106 br label %for.body 107 108for.cond.cleanup: 109 ret void 110 111for.body: 112 %i.09 = phi i32 [ 0, %entry ], [ %add3, %for.body ] 113 %arrayidx = getelementptr inbounds i64, i64* %B, i32 %i.09 114 %0 = load i64, i64* %arrayidx, align 8 115 %arrayidx1 = getelementptr inbounds i64, i64* %C, i32 %i.09 116 %1 = load i64, i64* %arrayidx1, align 8 117 %add = add nsw i64 %1, %0 118 %arrayidx2 = getelementptr inbounds i64, i64* %A, i32 %i.09 119 store i64 %add, i64* %arrayidx2, align 8 120 %add3 = add nuw nsw i32 %i.09, 1 121 %exitcond = icmp eq i32 %add3, 431 122 br i1 %exitcond, label %for.cond.cleanup, label %for.body 123} 124 125define void @narrowing_load_not_allowed(i8* noalias nocapture %A, i8* noalias nocapture readonly %B, i16* noalias nocapture readonly %C) #0 { 126; CHECK-LABEL: @narrowing_load_not_allowed( 127; CHECK-NEXT: entry: 128; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 129; CHECK: vector.ph: 130; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 131; CHECK: vector.body: 132; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 133; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 134; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, i16* [[C:%.*]], i32 [[TMP0]] 135; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i16, i16* [[TMP1]], i32 0 136; CHECK-NEXT: [[TMP3:%.*]] = bitcast i16* [[TMP2]] to <8 x i16>* 137; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <8 x i16>, <8 x i16>* [[TMP3]], align 2 138; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8* [[B:%.*]], i32 [[TMP0]] 139; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, i8* [[TMP4]], i32 0 140; CHECK-NEXT: [[TMP6:%.*]] = bitcast i8* [[TMP5]] to <8 x i8>* 141; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <8 x i8>, <8 x i8>* [[TMP6]], align 1 142; CHECK-NEXT: [[TMP7:%.*]] = trunc <8 x i16> [[WIDE_LOAD]] to <8 x i8> 143; CHECK-NEXT: [[TMP8:%.*]] = add <8 x i8> [[WIDE_LOAD1]], [[TMP7]] 144; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds i8, i8* [[A:%.*]], i32 [[TMP0]] 145; CHECK-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, i8* [[TMP9]], i32 0 146; CHECK-NEXT: [[TMP11:%.*]] = bitcast i8* [[TMP10]] to <8 x i8>* 147; CHECK-NEXT: store <8 x i8> [[TMP8]], <8 x i8>* [[TMP11]], align 1 148; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 8 149; CHECK-NEXT: [[TMP12:%.*]] = icmp eq i32 [[INDEX_NEXT]], 424 150; CHECK-NEXT: br i1 [[TMP12]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP4:!llvm.loop !.*]] 151; CHECK: middle.block: 152; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 424 153; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 154; CHECK: scalar.ph: 155; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 424, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ] 156; CHECK-NEXT: br label [[FOR_BODY:%.*]] 157; CHECK: for.cond.cleanup: 158; CHECK-NEXT: ret void 159; CHECK: for.body: 160; CHECK-NEXT: [[I_012:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD6:%.*]], [[FOR_BODY]] ] 161; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i16, i16* [[C]], i32 [[I_012]] 162; CHECK-NEXT: [[TMP13:%.*]] = load i16, i16* [[ARRAYIDX]], align 2 163; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, i8* [[B]], i32 [[I_012]] 164; CHECK-NEXT: [[TMP14:%.*]] = load i8, i8* [[ARRAYIDX1]], align 1 165; CHECK-NEXT: [[CONV3:%.*]] = trunc i16 [[TMP13]] to i8 166; CHECK-NEXT: [[ADD:%.*]] = add i8 [[TMP14]], [[CONV3]] 167; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds i8, i8* [[A]], i32 [[I_012]] 168; CHECK-NEXT: store i8 [[ADD]], i8* [[ARRAYIDX5]], align 1 169; CHECK-NEXT: [[ADD6]] = add nuw nsw i32 [[I_012]], 1 170; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD6]], 431 171; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP5:!llvm.loop !.*]] 172; 173entry: 174 br label %for.body 175 176for.cond.cleanup: ; preds = %for.body 177 ret void 178 179for.body: ; preds = %for.body, %entry 180 %i.012 = phi i32 [ 0, %entry ], [ %add6, %for.body ] 181 %arrayidx = getelementptr inbounds i16, i16* %C, i32 %i.012 182 %0 = load i16, i16* %arrayidx, align 2 183 %arrayidx1 = getelementptr inbounds i8, i8* %B, i32 %i.012 184 %1 = load i8, i8* %arrayidx1, align 1 185 %conv3 = trunc i16 %0 to i8 186 %add = add i8 %1, %conv3 187 %arrayidx5 = getelementptr inbounds i8, i8* %A, i32 %i.012 188 store i8 %add, i8* %arrayidx5, align 1 189 %add6 = add nuw nsw i32 %i.012, 1 190 %exitcond = icmp eq i32 %add6, 431 191 br i1 %exitcond, label %for.cond.cleanup, label %for.body 192} 193 194; This is a trunc not connected to a store, so we don't allow this. 195; TODO: this is conservative, because the trunc is only used in the 196; loop control statements, and thus not affecting element sizes, so 197; we could allow this case. 198; 199define void @trunc_not_allowed(i32* noalias nocapture %A, i32* noalias nocapture readonly %B, i32* noalias nocapture readonly %C) #0 { 200; CHECK-LABEL: @trunc_not_allowed( 201; CHECK-NEXT: entry: 202; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 203; CHECK: vector.ph: 204; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 205; CHECK: vector.body: 206; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 207; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 208; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[TMP0]] 209; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 210; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 211; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 212; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i32 [[TMP0]] 213; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, i32* [[TMP4]], i32 0 214; CHECK-NEXT: [[TMP6:%.*]] = bitcast i32* [[TMP5]] to <4 x i32>* 215; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP6]], align 4 216; CHECK-NEXT: [[TMP7:%.*]] = add nsw <4 x i32> [[WIDE_LOAD1]], [[WIDE_LOAD]] 217; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[TMP0]] 218; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP8]], i32 0 219; CHECK-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP9]] to <4 x i32>* 220; CHECK-NEXT: store <4 x i32> [[TMP7]], <4 x i32>* [[TMP10]], align 4 221; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 222; CHECK-NEXT: [[TMP11:%.*]] = icmp eq i32 [[INDEX_NEXT]], 428 223; CHECK-NEXT: br i1 [[TMP11]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP6:!llvm.loop !.*]] 224; CHECK: middle.block: 225; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 428 226; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 227; CHECK: scalar.ph: 228; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 428, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ] 229; CHECK-NEXT: br label [[FOR_BODY:%.*]] 230; CHECK: for.cond.cleanup: 231; CHECK-NEXT: ret void 232; CHECK: for.body: 233; CHECK-NEXT: [[I_09:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD3:%.*]], [[FOR_BODY]] ] 234; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[I_09]] 235; CHECK-NEXT: [[TMP12:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 236; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, i32* [[C]], i32 [[I_09]] 237; CHECK-NEXT: [[TMP13:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4 238; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP13]], [[TMP12]] 239; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[I_09]] 240; CHECK-NEXT: store i32 [[ADD]], i32* [[ARRAYIDX2]], align 4 241; CHECK-NEXT: [[ADD3]] = add nuw nsw i32 [[I_09]], 1 242; CHECK-NEXT: [[ADD_IV:%.*]] = trunc i32 [[ADD3]] to i16 243; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i16 [[ADD_IV]], 431 244; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP7:!llvm.loop !.*]] 245; 246entry: 247 br label %for.body 248 249for.cond.cleanup: 250 ret void 251 252for.body: 253 %i.09 = phi i32 [ 0, %entry ], [ %add3, %for.body ] 254 %arrayidx = getelementptr inbounds i32, i32* %B, i32 %i.09 255 %0 = load i32, i32* %arrayidx, align 4 256 %arrayidx1 = getelementptr inbounds i32, i32* %C, i32 %i.09 257 %1 = load i32, i32* %arrayidx1, align 4 258 %add = add nsw i32 %1, %0 259 %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %i.09 260 store i32 %add, i32* %arrayidx2, align 4 261 %add3 = add nuw nsw i32 %i.09, 1 262 263 %add.iv = trunc i32 %add3 to i16 264 265 %exitcond = icmp eq i16 %add.iv, 431 266 br i1 %exitcond, label %for.cond.cleanup, label %for.body 267} 268 269; Test directions for array indices i and N-1. I.e. check strides 1 and -1, and 270; force vectorisation with a loop hint. 271; 272define void @strides_different_direction(i32* noalias nocapture %A, i32* noalias nocapture readonly %B, i32* noalias nocapture readonly %C, i32 %N) #0 { 273; CHECK-LABEL: @strides_different_direction( 274; CHECK-NEXT: entry: 275; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]] 276; CHECK: vector.scevcheck: 277; CHECK-NEXT: [[MUL:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 1, i32 430) 278; CHECK-NEXT: [[MUL_RESULT:%.*]] = extractvalue { i32, i1 } [[MUL]], 0 279; CHECK-NEXT: [[MUL_OVERFLOW:%.*]] = extractvalue { i32, i1 } [[MUL]], 1 280; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[N:%.*]], [[MUL_RESULT]] 281; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[N]], [[MUL_RESULT]] 282; CHECK-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP1]], [[N]] 283; CHECK-NEXT: [[TMP3:%.*]] = icmp slt i32 [[TMP0]], [[N]] 284; CHECK-NEXT: [[TMP4:%.*]] = select i1 true, i1 [[TMP2]], i1 [[TMP3]] 285; CHECK-NEXT: [[TMP5:%.*]] = or i1 [[TMP4]], [[MUL_OVERFLOW]] 286; CHECK-NEXT: [[TMP6:%.*]] = or i1 false, [[TMP5]] 287; CHECK-NEXT: br i1 [[TMP6]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]] 288; CHECK: vector.ph: 289; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 290; CHECK: vector.body: 291; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 292; CHECK-NEXT: [[TMP7:%.*]] = add i32 [[INDEX]], 0 293; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[TMP7]] 294; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP8]], i32 0 295; CHECK-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP9]] to <4 x i32>* 296; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP10]], align 4 297; CHECK-NEXT: [[TMP11:%.*]] = sub nsw i32 [[N]], [[TMP7]] 298; CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i32 [[TMP11]] 299; CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds i32, i32* [[TMP12]], i32 0 300; CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds i32, i32* [[TMP13]], i32 -3 301; CHECK-NEXT: [[TMP15:%.*]] = bitcast i32* [[TMP14]] to <4 x i32>* 302; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP15]], align 4 303; CHECK-NEXT: [[REVERSE:%.*]] = shufflevector <4 x i32> [[WIDE_LOAD1]], <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0> 304; CHECK-NEXT: [[TMP16:%.*]] = add nsw <4 x i32> [[REVERSE]], [[WIDE_LOAD]] 305; CHECK-NEXT: [[TMP17:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[TMP7]] 306; CHECK-NEXT: [[TMP18:%.*]] = getelementptr inbounds i32, i32* [[TMP17]], i32 0 307; CHECK-NEXT: [[TMP19:%.*]] = bitcast i32* [[TMP18]] to <4 x i32>* 308; CHECK-NEXT: store <4 x i32> [[TMP16]], <4 x i32>* [[TMP19]], align 4 309; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 310; CHECK-NEXT: [[TMP20:%.*]] = icmp eq i32 [[INDEX_NEXT]], 428 311; CHECK-NEXT: br i1 [[TMP20]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP8:!llvm.loop !.*]] 312; CHECK: middle.block: 313; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 428 314; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 315; CHECK: scalar.ph: 316; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 428, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ], [ 0, [[VECTOR_SCEVCHECK]] ] 317; CHECK-NEXT: br label [[FOR_BODY:%.*]] 318; CHECK: for.cond.cleanup: 319; CHECK-NEXT: ret void 320; CHECK: for.body: 321; CHECK-NEXT: [[I_09:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD3:%.*]], [[FOR_BODY]] ] 322; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[I_09]] 323; CHECK-NEXT: [[TMP21:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 324; CHECK-NEXT: [[SUB:%.*]] = sub nsw i32 [[N]], [[I_09]] 325; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, i32* [[C]], i32 [[SUB]] 326; CHECK-NEXT: [[TMP22:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4 327; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP22]], [[TMP21]] 328; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[I_09]] 329; CHECK-NEXT: store i32 [[ADD]], i32* [[ARRAYIDX2]], align 4 330; CHECK-NEXT: [[ADD3]] = add nuw nsw i32 [[I_09]], 1 331; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD3]], 431 332; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP9:!llvm.loop !.*]] 333; 334entry: 335 br label %for.body 336 337for.cond.cleanup: 338 ret void 339 340for.body: 341 %i.09 = phi i32 [ 0, %entry ], [ %add3, %for.body ] 342 %arrayidx = getelementptr inbounds i32, i32* %B, i32 %i.09 343 %0 = load i32, i32* %arrayidx, align 4 344 %sub = sub nsw i32 %N, %i.09 345 %arrayidx1 = getelementptr inbounds i32, i32* %C, i32 %sub 346 %1 = load i32, i32* %arrayidx1, align 4 347 %add = add nsw i32 %1, %0 348 %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %i.09 349 store i32 %add, i32* %arrayidx2, align 4 350 %add3 = add nuw nsw i32 %i.09, 1 351 %exitcond = icmp eq i32 %add3, 431 352 br i1 %exitcond, label %for.cond.cleanup, label %for.body, !llvm.loop !10 353} 354 355define void @too_many_loop_blocks(i32* noalias nocapture %A, i32* noalias nocapture readonly %B, i32* noalias nocapture readonly %C) #0 { 356; CHECK-LABEL: @too_many_loop_blocks( 357; CHECK-NEXT: entry: 358; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 359; CHECK: vector.ph: 360; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 361; CHECK: vector.body: 362; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 363; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 364; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[TMP0]] 365; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 366; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 367; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 368; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i32, i32* [[C:%.*]], i32 [[TMP0]] 369; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, i32* [[TMP4]], i32 0 370; CHECK-NEXT: [[TMP6:%.*]] = bitcast i32* [[TMP5]] to <4 x i32>* 371; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP6]], align 4 372; CHECK-NEXT: [[TMP7:%.*]] = add nsw <4 x i32> [[WIDE_LOAD1]], [[WIDE_LOAD]] 373; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[TMP0]] 374; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP8]], i32 0 375; CHECK-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP9]] to <4 x i32>* 376; CHECK-NEXT: store <4 x i32> [[TMP7]], <4 x i32>* [[TMP10]], align 4 377; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 378; CHECK-NEXT: [[TMP11:%.*]] = icmp eq i32 [[INDEX_NEXT]], 428 379; CHECK-NEXT: br i1 [[TMP11]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP10:!llvm.loop !.*]] 380; CHECK: middle.block: 381; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 428 382; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 383; CHECK: scalar.ph: 384; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 428, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ] 385; CHECK-NEXT: br label [[FOR_BODY:%.*]] 386; CHECK: for.cond.cleanup: 387; CHECK-NEXT: ret void 388; CHECK: for.body: 389; CHECK-NEXT: [[I_09:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD3:%.*]], [[LOOPINCR:%.*]] ] 390; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[I_09]] 391; CHECK-NEXT: [[TMP12:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 392; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, i32* [[C]], i32 [[I_09]] 393; CHECK-NEXT: [[TMP13:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4 394; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP13]], [[TMP12]] 395; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[I_09]] 396; CHECK-NEXT: store i32 [[ADD]], i32* [[ARRAYIDX2]], align 4 397; CHECK-NEXT: br label [[LOOPINCR]] 398; CHECK: loopincr: 399; CHECK-NEXT: [[ADD3]] = add nuw nsw i32 [[I_09]], 1 400; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD3]], 431 401; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP11:!llvm.loop !.*]] 402; 403entry: 404 br label %for.body 405 406for.cond.cleanup: 407 ret void 408 409for.body: 410 %i.09 = phi i32 [ 0, %entry ], [ %add3, %loopincr ] 411 %arrayidx = getelementptr inbounds i32, i32* %B, i32 %i.09 412 %0 = load i32, i32* %arrayidx, align 4 413 %arrayidx1 = getelementptr inbounds i32, i32* %C, i32 %i.09 414 %1 = load i32, i32* %arrayidx1, align 4 415 %add = add nsw i32 %1, %0 416 %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %i.09 417 store i32 %add, i32* %arrayidx2, align 4 418 br label %loopincr 419 420loopincr: 421 %add3 = add nuw nsw i32 %i.09, 1 422 %exitcond = icmp eq i32 %add3, 431 423 br i1 %exitcond, label %for.cond.cleanup, label %for.body 424} 425 426define void @double(double* noalias nocapture %A, double* noalias nocapture readonly %B, double* noalias nocapture readonly %C) #0 { 427; CHECK-LABEL: @double( 428; CHECK-NEXT: entry: 429; CHECK-NEXT: br label [[FOR_BODY:%.*]] 430; CHECK: for.cond.cleanup: 431; CHECK-NEXT: ret void 432; CHECK: for.body: 433; CHECK-NEXT: [[I_09:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[ADD3:%.*]], [[FOR_BODY]] ] 434; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds double, double* [[B:%.*]], i32 [[I_09]] 435; CHECK-NEXT: [[TMP0:%.*]] = load double, double* [[ARRAYIDX]], align 8 436; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds double, double* [[C:%.*]], i32 [[I_09]] 437; CHECK-NEXT: [[TMP1:%.*]] = load double, double* [[ARRAYIDX1]], align 8 438; CHECK-NEXT: [[ADD:%.*]] = fadd fast double [[TMP1]], [[TMP0]] 439; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds double, double* [[A:%.*]], i32 [[I_09]] 440; CHECK-NEXT: store double [[ADD]], double* [[ARRAYIDX2]], align 8 441; CHECK-NEXT: [[ADD3]] = add nuw nsw i32 [[I_09]], 1 442; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD3]], 431 443; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]] 444; 445entry: 446 br label %for.body 447 448for.cond.cleanup: 449 ret void 450 451for.body: 452 %i.09 = phi i32 [ 0, %entry ], [ %add3, %for.body ] 453 %arrayidx = getelementptr inbounds double, double* %B, i32 %i.09 454 %0 = load double, double* %arrayidx, align 8 455 %arrayidx1 = getelementptr inbounds double, double* %C, i32 %i.09 456 %1 = load double, double* %arrayidx1, align 8 457 %add = fadd fast double %1, %0 458 %arrayidx2 = getelementptr inbounds double, double* %A, i32 %i.09 459 store double %add, double* %arrayidx2, align 8 460 %add3 = add nuw nsw i32 %i.09, 1 461 %exitcond = icmp eq i32 %add3, 431 462 br i1 %exitcond, label %for.cond.cleanup, label %for.body 463} 464 465define void @fptrunc_not_allowed(float* noalias nocapture %A, float* noalias nocapture readonly %B, float* noalias nocapture readonly %C, half* noalias nocapture %D) #0 { 466; CHECK-LABEL: @fptrunc_not_allowed( 467; CHECK-NEXT: entry: 468; CHECK-NEXT: br label [[FOR_BODY:%.*]] 469; CHECK: for.cond.cleanup: 470; CHECK-NEXT: ret void 471; CHECK: for.body: 472; CHECK-NEXT: [[I_017:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[ADD6:%.*]], [[FOR_BODY]] ] 473; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i32 [[I_017]] 474; CHECK-NEXT: [[TMP0:%.*]] = load float, float* [[ARRAYIDX]], align 4 475; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, float* [[C:%.*]], i32 [[I_017]] 476; CHECK-NEXT: [[TMP1:%.*]] = load float, float* [[ARRAYIDX1]], align 4 477; CHECK-NEXT: [[ADD:%.*]] = fadd fast float [[TMP1]], [[TMP0]] 478; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i32 [[I_017]] 479; CHECK-NEXT: store float [[ADD]], float* [[ARRAYIDX2]], align 4 480; CHECK-NEXT: [[CONV:%.*]] = fptrunc float [[ADD]] to half 481; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast half [[CONV]], 0xH4000 482; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds half, half* [[D:%.*]], i32 [[I_017]] 483; CHECK-NEXT: store half [[FACTOR]], half* [[ARRAYIDX5]], align 2 484; CHECK-NEXT: [[ADD6]] = add nuw nsw i32 [[I_017]], 1 485; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD6]], 431 486; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]] 487; 488entry: 489 br label %for.body 490 491for.cond.cleanup: 492 ret void 493 494for.body: 495 %i.017 = phi i32 [ 0, %entry ], [ %add6, %for.body ] 496 %arrayidx = getelementptr inbounds float, float* %B, i32 %i.017 497 %0 = load float, float* %arrayidx, align 4 498 %arrayidx1 = getelementptr inbounds float, float* %C, i32 %i.017 499 %1 = load float, float* %arrayidx1, align 4 500 %add = fadd fast float %1, %0 501 %arrayidx2 = getelementptr inbounds float, float* %A, i32 %i.017 502 store float %add, float* %arrayidx2, align 4 503 %conv = fptrunc float %add to half 504 %factor = fmul fast half %conv, 0xH4000 505 %arrayidx5 = getelementptr inbounds half, half* %D, i32 %i.017 506 store half %factor, half* %arrayidx5, align 2 507 %add6 = add nuw nsw i32 %i.017, 1 508 %exitcond = icmp eq i32 %add6, 431 509 br i1 %exitcond, label %for.cond.cleanup, label %for.body 510} 511 512; This is a select which isn't a max or min (it isn't live-out), that we don't 513; want to tail-fold. Because this select will result in some mov lanes, 514; which aren't supported by the lowoverhead loop pass, causing the tail-predication 515; to be reverted which is expensive and what we would like to avoid. 516; 517define dso_local void @select_not_allowed(i32* noalias nocapture %A, i32* noalias nocapture readonly %B, i32* noalias nocapture readonly %C, i32 %N, i32* noalias nocapture readonly %Cond) { 518; CHECK-LABEL: @select_not_allowed( 519; CHECK-NEXT: entry: 520; CHECK-NEXT: [[CMP10:%.*]] = icmp sgt i32 [[N:%.*]], 0 521; CHECK-NEXT: br i1 [[CMP10]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 522; CHECK: for.body.preheader: 523; CHECK-NEXT: br label [[FOR_BODY:%.*]] 524; CHECK: for.cond.cleanup.loopexit: 525; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 526; CHECK: for.cond.cleanup: 527; CHECK-NEXT: ret void 528; CHECK: for.body: 529; CHECK-NEXT: [[I_011:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 530; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[COND:%.*]], i32 [[I_011]] 531; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 532; CHECK-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[TMP0]], 0 533; CHECK-NEXT: [[C_B:%.*]] = select i1 [[TOBOOL_NOT]], i32* [[C:%.*]], i32* [[B:%.*]] 534; CHECK-NEXT: [[COND_IN:%.*]] = getelementptr inbounds i32, i32* [[C_B]], i32 [[I_011]] 535; CHECK-NEXT: [[COND:%.*]] = load i32, i32* [[COND_IN]], align 4 536; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_011]] 537; CHECK-NEXT: store i32 [[COND]], i32* [[ARRAYIDX3]], align 4 538; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_011]], 1 539; CHECK-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i32 [[INC]], [[N]] 540; CHECK-NEXT: br i1 [[EXITCOND_NOT]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY]] 541; 542entry: 543 %cmp10 = icmp sgt i32 %N, 0 544 br i1 %cmp10, label %for.body.preheader, label %for.cond.cleanup 545 546for.body.preheader: ; preds = %entry 547 br label %for.body 548 549for.cond.cleanup.loopexit: ; preds = %for.body 550 br label %for.cond.cleanup 551 552for.cond.cleanup: ; preds = %for.cond.cleanup.loopexit, %entry 553 ret void 554 555for.body: ; preds = %for.body.preheader, %for.body 556 %i.011 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] 557 %arrayidx = getelementptr inbounds i32, i32* %Cond, i32 %i.011 558 %0 = load i32, i32* %arrayidx, align 4 559 %tobool.not = icmp eq i32 %0, 0 560 %C.B = select i1 %tobool.not, i32* %C, i32* %B 561 %cond.in = getelementptr inbounds i32, i32* %C.B, i32 %i.011 562 %cond = load i32, i32* %cond.in, align 4 563 %arrayidx3 = getelementptr inbounds i32, i32* %A, i32 %i.011 564 store i32 %cond, i32* %arrayidx3, align 4 565 %inc = add nuw nsw i32 %i.011, 1 566 %exitcond.not = icmp eq i32 %inc, %N 567 br i1 %exitcond.not, label %for.cond.cleanup.loopexit, label %for.body 568} 569 570define i32 @i32_smin_reduction(i32* nocapture readonly %x, i32 %n) #0 { 571; CHECK-LABEL: @i32_smin_reduction( 572; CHECK-NEXT: entry: 573; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 574; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 575; CHECK: for.body.preheader: 576; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 577; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 578; CHECK: vector.ph: 579; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 580; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 581; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 582; CHECK: vector.body: 583; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 584; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 2147483647, i32 2147483647, i32 2147483647, i32 2147483647>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 585; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 586; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 587; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 588; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 589; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 590; CHECK-NEXT: [[TMP4:%.*]] = icmp slt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 591; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 592; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 593; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 594; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP12:!llvm.loop !.*]] 595; CHECK: middle.block: 596; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> [[TMP5]]) 597; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 598; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 599; CHECK: scalar.ph: 600; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 601; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ 2147483647, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 602; CHECK-NEXT: br label [[FOR_BODY:%.*]] 603; CHECK: for.body: 604; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 605; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 606; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 607; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 608; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[R_07]], [[TMP8]] 609; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 610; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 611; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 612; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP13:!llvm.loop !.*]] 613; CHECK: for.cond.cleanup.loopexit: 614; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 615; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 616; CHECK: for.cond.cleanup: 617; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ 2147483647, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 618; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 619; 620entry: 621 %cmp6 = icmp sgt i32 %n, 0 622 br i1 %cmp6, label %for.body, label %for.cond.cleanup 623 624for.body: ; preds = %entry, %for.body 625 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 626 %r.07 = phi i32 [ %add, %for.body ], [ 2147483647, %entry ] 627 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 628 %0 = load i32, i32* %arrayidx, align 4 629 %c = icmp slt i32 %r.07, %0 630 %add = select i1 %c, i32 %r.07, i32 %0 631 %inc = add nuw nsw i32 %i.08, 1 632 %exitcond = icmp eq i32 %inc, %n 633 br i1 %exitcond, label %for.cond.cleanup, label %for.body 634 635for.cond.cleanup: ; preds = %for.body, %entry 636 %r.0.lcssa = phi i32 [ 2147483647, %entry ], [ %add, %for.body ] 637 ret i32 %r.0.lcssa 638} 639 640define i32 @i32_smax_reduction(i32* nocapture readonly %x, i32 %n) #0 { 641; CHECK-LABEL: @i32_smax_reduction( 642; CHECK-NEXT: entry: 643; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 644; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 645; CHECK: for.body.preheader: 646; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 647; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 648; CHECK: vector.ph: 649; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 650; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 651; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 652; CHECK: vector.body: 653; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 654; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 655; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 656; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 657; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 658; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 659; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 660; CHECK-NEXT: [[TMP4:%.*]] = icmp sgt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 661; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 662; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 663; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 664; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP14:!llvm.loop !.*]] 665; CHECK: middle.block: 666; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> [[TMP5]]) 667; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 668; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 669; CHECK: scalar.ph: 670; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 671; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ -2147483648, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 672; CHECK-NEXT: br label [[FOR_BODY:%.*]] 673; CHECK: for.body: 674; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 675; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 676; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 677; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 678; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 [[R_07]], [[TMP8]] 679; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 680; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 681; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 682; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP15:!llvm.loop !.*]] 683; CHECK: for.cond.cleanup.loopexit: 684; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 685; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 686; CHECK: for.cond.cleanup: 687; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ -2147483648, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 688; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 689; 690entry: 691 %cmp6 = icmp sgt i32 %n, 0 692 br i1 %cmp6, label %for.body, label %for.cond.cleanup 693 694for.body: ; preds = %entry, %for.body 695 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 696 %r.07 = phi i32 [ %add, %for.body ], [ -2147483648, %entry ] 697 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 698 %0 = load i32, i32* %arrayidx, align 4 699 %c = icmp sgt i32 %r.07, %0 700 %add = select i1 %c, i32 %r.07, i32 %0 701 %inc = add nuw nsw i32 %i.08, 1 702 %exitcond = icmp eq i32 %inc, %n 703 br i1 %exitcond, label %for.cond.cleanup, label %for.body 704 705for.cond.cleanup: ; preds = %for.body, %entry 706 %r.0.lcssa = phi i32 [ -2147483648, %entry ], [ %add, %for.body ] 707 ret i32 %r.0.lcssa 708} 709 710define i32 @i32_umin_reduction(i32* nocapture readonly %x, i32 %n) #0 { 711; CHECK-LABEL: @i32_umin_reduction( 712; CHECK-NEXT: entry: 713; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 714; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 715; CHECK: for.body.preheader: 716; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 717; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 718; CHECK: vector.ph: 719; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 720; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 721; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 722; CHECK: vector.body: 723; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 724; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 -1, i32 -1, i32 -1, i32 -1>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 725; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 726; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 727; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 728; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 729; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 730; CHECK-NEXT: [[TMP4:%.*]] = icmp ult <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 731; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 732; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 733; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 734; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP16:!llvm.loop !.*]] 735; CHECK: middle.block: 736; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> [[TMP5]]) 737; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 738; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 739; CHECK: scalar.ph: 740; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 741; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ -1, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 742; CHECK-NEXT: br label [[FOR_BODY:%.*]] 743; CHECK: for.body: 744; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 745; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 746; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 747; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 748; CHECK-NEXT: [[C:%.*]] = icmp ult i32 [[R_07]], [[TMP8]] 749; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 750; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 751; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 752; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP17:!llvm.loop !.*]] 753; CHECK: for.cond.cleanup.loopexit: 754; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 755; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 756; CHECK: for.cond.cleanup: 757; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ -1, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 758; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 759; 760entry: 761 %cmp6 = icmp sgt i32 %n, 0 762 br i1 %cmp6, label %for.body, label %for.cond.cleanup 763 764for.body: ; preds = %entry, %for.body 765 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 766 %r.07 = phi i32 [ %add, %for.body ], [ 4294967295, %entry ] 767 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 768 %0 = load i32, i32* %arrayidx, align 4 769 %c = icmp ult i32 %r.07, %0 770 %add = select i1 %c, i32 %r.07, i32 %0 771 %inc = add nuw nsw i32 %i.08, 1 772 %exitcond = icmp eq i32 %inc, %n 773 br i1 %exitcond, label %for.cond.cleanup, label %for.body 774 775for.cond.cleanup: ; preds = %for.body, %entry 776 %r.0.lcssa = phi i32 [ 4294967295, %entry ], [ %add, %for.body ] 777 ret i32 %r.0.lcssa 778} 779 780define i32 @i32_umax_reduction(i32* nocapture readonly %x, i32 %n) #0 { 781; CHECK-LABEL: @i32_umax_reduction( 782; CHECK-NEXT: entry: 783; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 784; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 785; CHECK: for.body.preheader: 786; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 787; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 788; CHECK: vector.ph: 789; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 790; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 791; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 792; CHECK: vector.body: 793; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 794; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ zeroinitializer, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 795; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 796; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 797; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 798; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 799; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 800; CHECK-NEXT: [[TMP4:%.*]] = icmp ugt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 801; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 802; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 803; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 804; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP18:!llvm.loop !.*]] 805; CHECK: middle.block: 806; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.umax.v4i32(<4 x i32> [[TMP5]]) 807; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 808; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 809; CHECK: scalar.ph: 810; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 811; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ 0, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 812; CHECK-NEXT: br label [[FOR_BODY:%.*]] 813; CHECK: for.body: 814; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 815; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 816; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 817; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 818; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 [[R_07]], [[TMP8]] 819; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 820; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 821; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 822; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP19:!llvm.loop !.*]] 823; CHECK: for.cond.cleanup.loopexit: 824; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 825; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 826; CHECK: for.cond.cleanup: 827; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 828; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 829; 830entry: 831 %cmp6 = icmp sgt i32 %n, 0 832 br i1 %cmp6, label %for.body, label %for.cond.cleanup 833 834for.body: ; preds = %entry, %for.body 835 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 836 %r.07 = phi i32 [ %add, %for.body ], [ 0, %entry ] 837 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 838 %0 = load i32, i32* %arrayidx, align 4 839 %c = icmp ugt i32 %r.07, %0 840 %add = select i1 %c, i32 %r.07, i32 %0 841 %inc = add nuw nsw i32 %i.08, 1 842 %exitcond = icmp eq i32 %inc, %n 843 br i1 %exitcond, label %for.cond.cleanup, label %for.body 844 845for.cond.cleanup: ; preds = %for.body, %entry 846 %r.0.lcssa = phi i32 [ 0, %entry ], [ %add, %for.body ] 847 ret i32 %r.0.lcssa 848} 849 850!10 = distinct !{!10, !11} 851!11 = !{!"llvm.loop.vectorize.width", i32 4} 852