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 i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 469; CHECK: vector.ph: 470; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 471; CHECK: vector.body: 472; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 473; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 474; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i32 [[TMP0]] 475; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds float, float* [[TMP1]], i32 0 476; CHECK-NEXT: [[TMP3:%.*]] = bitcast float* [[TMP2]] to <4 x float>* 477; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x float>, <4 x float>* [[TMP3]], align 4 478; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds float, float* [[C:%.*]], i32 [[TMP0]] 479; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds float, float* [[TMP4]], i32 0 480; CHECK-NEXT: [[TMP6:%.*]] = bitcast float* [[TMP5]] to <4 x float>* 481; CHECK-NEXT: [[WIDE_LOAD1:%.*]] = load <4 x float>, <4 x float>* [[TMP6]], align 4 482; CHECK-NEXT: [[TMP7:%.*]] = fadd fast <4 x float> [[WIDE_LOAD1]], [[WIDE_LOAD]] 483; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i32 [[TMP0]] 484; CHECK-NEXT: [[TMP9:%.*]] = getelementptr inbounds float, float* [[TMP8]], i32 0 485; CHECK-NEXT: [[TMP10:%.*]] = bitcast float* [[TMP9]] to <4 x float>* 486; CHECK-NEXT: store <4 x float> [[TMP7]], <4 x float>* [[TMP10]], align 4 487; CHECK-NEXT: [[TMP11:%.*]] = fptrunc <4 x float> [[TMP7]] to <4 x half> 488; CHECK-NEXT: [[TMP12:%.*]] = fmul fast <4 x half> [[TMP11]], <half 0xH4000, half 0xH4000, half 0xH4000, half 0xH4000> 489; CHECK-NEXT: [[TMP13:%.*]] = getelementptr inbounds half, half* [[D:%.*]], i32 [[TMP0]] 490; CHECK-NEXT: [[TMP14:%.*]] = getelementptr inbounds half, half* [[TMP13]], i32 0 491; CHECK-NEXT: [[TMP15:%.*]] = bitcast half* [[TMP14]] to <4 x half>* 492; CHECK-NEXT: store <4 x half> [[TMP12]], <4 x half>* [[TMP15]], align 2 493; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 494; CHECK-NEXT: [[TMP16:%.*]] = icmp eq i32 [[INDEX_NEXT]], 428 495; CHECK-NEXT: br i1 [[TMP16]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP12:!llvm.loop !.*]] 496; CHECK: middle.block: 497; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 431, 428 498; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP:%.*]], label [[SCALAR_PH]] 499; CHECK: scalar.ph: 500; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ 428, [[MIDDLE_BLOCK]] ], [ 0, [[ENTRY:%.*]] ] 501; CHECK-NEXT: br label [[FOR_BODY:%.*]] 502; CHECK: for.cond.cleanup: 503; CHECK-NEXT: ret void 504; CHECK: for.body: 505; CHECK-NEXT: [[I_017:%.*]] = phi i32 [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ], [ [[ADD6:%.*]], [[FOR_BODY]] ] 506; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[B]], i32 [[I_017]] 507; CHECK-NEXT: [[TMP17:%.*]] = load float, float* [[ARRAYIDX]], align 4 508; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds float, float* [[C]], i32 [[I_017]] 509; CHECK-NEXT: [[TMP18:%.*]] = load float, float* [[ARRAYIDX1]], align 4 510; CHECK-NEXT: [[ADD:%.*]] = fadd fast float [[TMP18]], [[TMP17]] 511; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds float, float* [[A]], i32 [[I_017]] 512; CHECK-NEXT: store float [[ADD]], float* [[ARRAYIDX2]], align 4 513; CHECK-NEXT: [[CONV:%.*]] = fptrunc float [[ADD]] to half 514; CHECK-NEXT: [[FACTOR:%.*]] = fmul fast half [[CONV]], 0xH4000 515; CHECK-NEXT: [[ARRAYIDX5:%.*]] = getelementptr inbounds half, half* [[D]], i32 [[I_017]] 516; CHECK-NEXT: store half [[FACTOR]], half* [[ARRAYIDX5]], align 2 517; CHECK-NEXT: [[ADD6]] = add nuw nsw i32 [[I_017]], 1 518; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[ADD6]], 431 519; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY]], [[LOOP13:!llvm.loop !.*]] 520; 521entry: 522 br label %for.body 523 524for.cond.cleanup: 525 ret void 526 527for.body: 528 %i.017 = phi i32 [ 0, %entry ], [ %add6, %for.body ] 529 %arrayidx = getelementptr inbounds float, float* %B, i32 %i.017 530 %0 = load float, float* %arrayidx, align 4 531 %arrayidx1 = getelementptr inbounds float, float* %C, i32 %i.017 532 %1 = load float, float* %arrayidx1, align 4 533 %add = fadd fast float %1, %0 534 %arrayidx2 = getelementptr inbounds float, float* %A, i32 %i.017 535 store float %add, float* %arrayidx2, align 4 536 %conv = fptrunc float %add to half 537 %factor = fmul fast half %conv, 0xH4000 538 %arrayidx5 = getelementptr inbounds half, half* %D, i32 %i.017 539 store half %factor, half* %arrayidx5, align 2 540 %add6 = add nuw nsw i32 %i.017, 1 541 %exitcond = icmp eq i32 %add6, 431 542 br i1 %exitcond, label %for.cond.cleanup, label %for.body 543} 544 545; This is a select which isn't a max or min (it isn't live-out), that we don't 546; want to tail-fold. Because this select will result in some mov lanes, 547; which aren't supported by the lowoverhead loop pass, causing the tail-predication 548; to be reverted which is expensive and what we would like to avoid. 549; 550define 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) { 551; CHECK-LABEL: @select_not_allowed( 552; CHECK-NEXT: entry: 553; CHECK-NEXT: [[CMP10:%.*]] = icmp sgt i32 [[N:%.*]], 0 554; CHECK-NEXT: br i1 [[CMP10]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 555; CHECK: for.body.preheader: 556; CHECK-NEXT: br label [[FOR_BODY:%.*]] 557; CHECK: for.cond.cleanup.loopexit: 558; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 559; CHECK: for.cond.cleanup: 560; CHECK-NEXT: ret void 561; CHECK: for.body: 562; CHECK-NEXT: [[I_011:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 563; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[COND:%.*]], i32 [[I_011]] 564; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 565; CHECK-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[TMP0]], 0 566; CHECK-NEXT: [[C_B:%.*]] = select i1 [[TOBOOL_NOT]], i32* [[C:%.*]], i32* [[B:%.*]] 567; CHECK-NEXT: [[COND_IN:%.*]] = getelementptr inbounds i32, i32* [[C_B]], i32 [[I_011]] 568; CHECK-NEXT: [[COND:%.*]] = load i32, i32* [[COND_IN]], align 4 569; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_011]] 570; CHECK-NEXT: store i32 [[COND]], i32* [[ARRAYIDX3]], align 4 571; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_011]], 1 572; CHECK-NEXT: [[EXITCOND_NOT:%.*]] = icmp eq i32 [[INC]], [[N]] 573; CHECK-NEXT: br i1 [[EXITCOND_NOT]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[FOR_BODY]] 574; 575entry: 576 %cmp10 = icmp sgt i32 %N, 0 577 br i1 %cmp10, label %for.body.preheader, label %for.cond.cleanup 578 579for.body.preheader: ; preds = %entry 580 br label %for.body 581 582for.cond.cleanup.loopexit: ; preds = %for.body 583 br label %for.cond.cleanup 584 585for.cond.cleanup: ; preds = %for.cond.cleanup.loopexit, %entry 586 ret void 587 588for.body: ; preds = %for.body.preheader, %for.body 589 %i.011 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] 590 %arrayidx = getelementptr inbounds i32, i32* %Cond, i32 %i.011 591 %0 = load i32, i32* %arrayidx, align 4 592 %tobool.not = icmp eq i32 %0, 0 593 %C.B = select i1 %tobool.not, i32* %C, i32* %B 594 %cond.in = getelementptr inbounds i32, i32* %C.B, i32 %i.011 595 %cond = load i32, i32* %cond.in, align 4 596 %arrayidx3 = getelementptr inbounds i32, i32* %A, i32 %i.011 597 store i32 %cond, i32* %arrayidx3, align 4 598 %inc = add nuw nsw i32 %i.011, 1 599 %exitcond.not = icmp eq i32 %inc, %N 600 br i1 %exitcond.not, label %for.cond.cleanup.loopexit, label %for.body 601} 602 603define i32 @i32_smin_reduction(i32* nocapture readonly %x, i32 %n) #0 { 604; CHECK-LABEL: @i32_smin_reduction( 605; CHECK-NEXT: entry: 606; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 607; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 608; CHECK: for.body.preheader: 609; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 610; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 611; CHECK: vector.ph: 612; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 613; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 614; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 615; CHECK: vector.body: 616; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 617; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 2147483647, i32 2147483647, i32 2147483647, i32 2147483647>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 618; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 619; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 620; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 621; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 622; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 623; CHECK-NEXT: [[TMP4:%.*]] = icmp slt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 624; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 625; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 626; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 627; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP14:!llvm.loop !.*]] 628; CHECK: middle.block: 629; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> [[TMP5]]) 630; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 631; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 632; CHECK: scalar.ph: 633; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 634; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ 2147483647, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 635; CHECK-NEXT: br label [[FOR_BODY:%.*]] 636; CHECK: for.body: 637; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 638; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 639; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 640; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 641; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[R_07]], [[TMP8]] 642; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 643; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 644; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 645; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP15:!llvm.loop !.*]] 646; CHECK: for.cond.cleanup.loopexit: 647; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 648; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 649; CHECK: for.cond.cleanup: 650; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ 2147483647, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 651; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 652; 653entry: 654 %cmp6 = icmp sgt i32 %n, 0 655 br i1 %cmp6, label %for.body, label %for.cond.cleanup 656 657for.body: ; preds = %entry, %for.body 658 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 659 %r.07 = phi i32 [ %add, %for.body ], [ 2147483647, %entry ] 660 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 661 %0 = load i32, i32* %arrayidx, align 4 662 %c = icmp slt i32 %r.07, %0 663 %add = select i1 %c, i32 %r.07, i32 %0 664 %inc = add nuw nsw i32 %i.08, 1 665 %exitcond = icmp eq i32 %inc, %n 666 br i1 %exitcond, label %for.cond.cleanup, label %for.body 667 668for.cond.cleanup: ; preds = %for.body, %entry 669 %r.0.lcssa = phi i32 [ 2147483647, %entry ], [ %add, %for.body ] 670 ret i32 %r.0.lcssa 671} 672 673define i32 @i32_smax_reduction(i32* nocapture readonly %x, i32 %n) #0 { 674; CHECK-LABEL: @i32_smax_reduction( 675; CHECK-NEXT: entry: 676; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 677; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 678; CHECK: for.body.preheader: 679; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 680; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 681; CHECK: vector.ph: 682; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 683; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 684; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 685; CHECK: vector.body: 686; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 687; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 688; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 689; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 690; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 691; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 692; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 693; CHECK-NEXT: [[TMP4:%.*]] = icmp sgt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 694; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 695; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 696; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 697; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP16:!llvm.loop !.*]] 698; CHECK: middle.block: 699; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> [[TMP5]]) 700; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 701; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 702; CHECK: scalar.ph: 703; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 704; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ -2147483648, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 705; CHECK-NEXT: br label [[FOR_BODY:%.*]] 706; CHECK: for.body: 707; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 708; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 709; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 710; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 711; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 [[R_07]], [[TMP8]] 712; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 713; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 714; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 715; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP17:!llvm.loop !.*]] 716; CHECK: for.cond.cleanup.loopexit: 717; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 718; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 719; CHECK: for.cond.cleanup: 720; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ -2147483648, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 721; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 722; 723entry: 724 %cmp6 = icmp sgt i32 %n, 0 725 br i1 %cmp6, label %for.body, label %for.cond.cleanup 726 727for.body: ; preds = %entry, %for.body 728 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 729 %r.07 = phi i32 [ %add, %for.body ], [ -2147483648, %entry ] 730 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 731 %0 = load i32, i32* %arrayidx, align 4 732 %c = icmp sgt i32 %r.07, %0 733 %add = select i1 %c, i32 %r.07, i32 %0 734 %inc = add nuw nsw i32 %i.08, 1 735 %exitcond = icmp eq i32 %inc, %n 736 br i1 %exitcond, label %for.cond.cleanup, label %for.body 737 738for.cond.cleanup: ; preds = %for.body, %entry 739 %r.0.lcssa = phi i32 [ -2147483648, %entry ], [ %add, %for.body ] 740 ret i32 %r.0.lcssa 741} 742 743define i32 @i32_umin_reduction(i32* nocapture readonly %x, i32 %n) #0 { 744; CHECK-LABEL: @i32_umin_reduction( 745; CHECK-NEXT: entry: 746; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 747; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 748; CHECK: for.body.preheader: 749; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 750; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 751; CHECK: vector.ph: 752; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 753; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 754; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 755; CHECK: vector.body: 756; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 757; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ <i32 -1, i32 -1, i32 -1, i32 -1>, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 758; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 759; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 760; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 761; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 762; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 763; CHECK-NEXT: [[TMP4:%.*]] = icmp ult <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 764; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 765; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 766; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 767; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP18:!llvm.loop !.*]] 768; CHECK: middle.block: 769; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> [[TMP5]]) 770; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 771; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 772; CHECK: scalar.ph: 773; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 774; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ -1, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 775; CHECK-NEXT: br label [[FOR_BODY:%.*]] 776; CHECK: for.body: 777; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 778; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 779; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 780; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 781; CHECK-NEXT: [[C:%.*]] = icmp ult i32 [[R_07]], [[TMP8]] 782; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 783; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 784; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 785; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP19:!llvm.loop !.*]] 786; CHECK: for.cond.cleanup.loopexit: 787; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 788; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 789; CHECK: for.cond.cleanup: 790; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ -1, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 791; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 792; 793entry: 794 %cmp6 = icmp sgt i32 %n, 0 795 br i1 %cmp6, label %for.body, label %for.cond.cleanup 796 797for.body: ; preds = %entry, %for.body 798 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 799 %r.07 = phi i32 [ %add, %for.body ], [ 4294967295, %entry ] 800 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 801 %0 = load i32, i32* %arrayidx, align 4 802 %c = icmp ult i32 %r.07, %0 803 %add = select i1 %c, i32 %r.07, i32 %0 804 %inc = add nuw nsw i32 %i.08, 1 805 %exitcond = icmp eq i32 %inc, %n 806 br i1 %exitcond, label %for.cond.cleanup, label %for.body 807 808for.cond.cleanup: ; preds = %for.body, %entry 809 %r.0.lcssa = phi i32 [ 4294967295, %entry ], [ %add, %for.body ] 810 ret i32 %r.0.lcssa 811} 812 813define i32 @i32_umax_reduction(i32* nocapture readonly %x, i32 %n) #0 { 814; CHECK-LABEL: @i32_umax_reduction( 815; CHECK-NEXT: entry: 816; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[N:%.*]], 0 817; CHECK-NEXT: br i1 [[CMP6]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] 818; CHECK: for.body.preheader: 819; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[N]], 4 820; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] 821; CHECK: vector.ph: 822; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i32 [[N]], 4 823; CHECK-NEXT: [[N_VEC:%.*]] = sub i32 [[N]], [[N_MOD_VF]] 824; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] 825; CHECK: vector.body: 826; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] 827; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <4 x i32> [ zeroinitializer, [[VECTOR_PH]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] 828; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[INDEX]], 0 829; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[TMP0]] 830; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP1]], i32 0 831; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP2]] to <4 x i32>* 832; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i32>, <4 x i32>* [[TMP3]], align 4 833; CHECK-NEXT: [[TMP4:%.*]] = icmp ugt <4 x i32> [[VEC_PHI]], [[WIDE_LOAD]] 834; CHECK-NEXT: [[TMP5]] = select <4 x i1> [[TMP4]], <4 x i32> [[VEC_PHI]], <4 x i32> [[WIDE_LOAD]] 835; CHECK-NEXT: [[INDEX_NEXT]] = add i32 [[INDEX]], 4 836; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 [[INDEX_NEXT]], [[N_VEC]] 837; CHECK-NEXT: br i1 [[TMP6]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], [[LOOP20:!llvm.loop !.*]] 838; CHECK: middle.block: 839; CHECK-NEXT: [[TMP7:%.*]] = call i32 @llvm.vector.reduce.umax.v4i32(<4 x i32> [[TMP5]]) 840; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i32 [[N]], [[N_VEC]] 841; CHECK-NEXT: br i1 [[CMP_N]], label [[FOR_COND_CLEANUP_LOOPEXIT:%.*]], label [[SCALAR_PH]] 842; CHECK: scalar.ph: 843; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i32 [ [[N_VEC]], [[MIDDLE_BLOCK]] ], [ 0, [[FOR_BODY_PREHEADER]] ] 844; CHECK-NEXT: [[BC_MERGE_RDX:%.*]] = phi i32 [ 0, [[FOR_BODY_PREHEADER]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 845; CHECK-NEXT: br label [[FOR_BODY:%.*]] 846; CHECK: for.body: 847; CHECK-NEXT: [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] 848; CHECK-NEXT: [[R_07:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ [[BC_MERGE_RDX]], [[SCALAR_PH]] ] 849; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[X]], i32 [[I_08]] 850; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX]], align 4 851; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 [[R_07]], [[TMP8]] 852; CHECK-NEXT: [[ADD]] = select i1 [[C]], i32 [[R_07]], i32 [[TMP8]] 853; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[I_08]], 1 854; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]] 855; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]], [[LOOP21:!llvm.loop !.*]] 856; CHECK: for.cond.cleanup.loopexit: 857; CHECK-NEXT: [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_BODY]] ], [ [[TMP7]], [[MIDDLE_BLOCK]] ] 858; CHECK-NEXT: br label [[FOR_COND_CLEANUP]] 859; CHECK: for.cond.cleanup: 860; CHECK-NEXT: [[R_0_LCSSA:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[ADD_LCSSA]], [[FOR_COND_CLEANUP_LOOPEXIT]] ] 861; CHECK-NEXT: ret i32 [[R_0_LCSSA]] 862; 863entry: 864 %cmp6 = icmp sgt i32 %n, 0 865 br i1 %cmp6, label %for.body, label %for.cond.cleanup 866 867for.body: ; preds = %entry, %for.body 868 %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ] 869 %r.07 = phi i32 [ %add, %for.body ], [ 0, %entry ] 870 %arrayidx = getelementptr inbounds i32, i32* %x, i32 %i.08 871 %0 = load i32, i32* %arrayidx, align 4 872 %c = icmp ugt i32 %r.07, %0 873 %add = select i1 %c, i32 %r.07, i32 %0 874 %inc = add nuw nsw i32 %i.08, 1 875 %exitcond = icmp eq i32 %inc, %n 876 br i1 %exitcond, label %for.cond.cleanup, label %for.body 877 878for.cond.cleanup: ; preds = %for.body, %entry 879 %r.0.lcssa = phi i32 [ 0, %entry ], [ %add, %for.body ] 880 ret i32 %r.0.lcssa 881} 882 883!10 = distinct !{!10, !11} 884!11 = !{!"llvm.loop.vectorize.width", i32 4} 885