llvm/test/Transforms/LoopVectorize/ARM/pointer_iv.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -passes=loop-vectorize,dce,instcombine,simplifycfg -S -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp,mve4beat -simplifycfg-require-and-preserve-domtree=1 -tail-predication=disabled < %s | FileCheck %s
   3
   4 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
   5 target triple = "thumbv8.1m.main-none-none-eabi"
   6
   7 define hidden void @pointer_phi_v4i32_add1(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %s, i32%y) {
   8 ; CHECK-LABEL: @pointer_phi_v4i32_add1(
   9 ; CHECK-NEXT:  entry:
  10 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[Y:%.*]], i64 0
  11 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x i32> [[BROADCAST_SPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
  12 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
  13 ; CHECK:       vector.body:
  14 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
  15 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
  16 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 [[OFFSET_IDX]]
  17 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 2
  18 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 [[OFFSET_IDX4]]
  19 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <4 x i32>, ptr [[NEXT_GEP]], align 4
  20 ; CHECK-NEXT:    [[TMP0:%.*]] = add nsw <4 x i32> [[WIDE_LOAD]], [[BROADCAST_SPLAT]]
  21 ; CHECK-NEXT:    store <4 x i32> [[TMP0]], ptr [[NEXT_GEP5]], align 4
  22 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
  23 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1000
  24 ; CHECK-NEXT:    br i1 [[TMP1]], label [[END:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
  25 ; CHECK:       end:
  26 ; CHECK-NEXT:    ret void
  27 ;
  28 entry:
  29   br label %for.body
  30 for.body:
  31   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
  32   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
  33   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
  34   %0 = load i32, ptr %A.addr.09, align 4
  35   %add.ptr = getelementptr inbounds i32, ptr %A.addr.09, i32 1
  36   %add = add nsw i32 %0, %y
  37   store i32 %add, ptr %B.addr.07, align 4
  38   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.07, i32 1
  39   %inc = add nuw nsw i32 %i.08, 1
  40   %exitcond = icmp eq i32 %inc, 1000
  41   br i1 %exitcond, label %end, label %for.body
  42 end:
  43   ret void
  44 }
  45
  46 define hidden void @pointer_phi_v4i32_add2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
  47 ; CHECK-LABEL: @pointer_phi_v4i32_add2(
  48 ; CHECK-NEXT:  entry:
  49 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 7968
  50 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 3984
  51 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[Y:%.*]], i64 0
  52 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x i32> [[BROADCAST_SPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
  53 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
  54 ; CHECK:       vector.body:
  55 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
  56 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 3
  57 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
  58 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 2
  59 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX4]]
  60 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <8 x i32>, ptr [[NEXT_GEP]], align 4
  61 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <8 x i32> [[WIDE_VEC]], <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  62 ; CHECK-NEXT:    [[TMP0:%.*]] = add nsw <4 x i32> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
  63 ; CHECK-NEXT:    store <4 x i32> [[TMP0]], ptr [[NEXT_GEP5]], align 4
  64 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
  65 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 996
  66 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP3:![0-9]+]]
  67 ; CHECK:       for.body:
  68 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
  69 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 996, [[VECTOR_BODY]] ]
  70 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
  71 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[A_ADDR_09]], align 4
  72 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 8
  73 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP2]], [[Y]]
  74 ; CHECK-NEXT:    store i32 [[ADD]], ptr [[B_ADDR_07]], align 4
  75 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 4
  76 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
  77 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
  78 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]]
  79 ; CHECK:       end:
  80 ; CHECK-NEXT:    ret void
  81 ;
  82 entry:
  83   br label %for.body
  84 for.body:
  85   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
  86   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
  87   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
  88   %0 = load i32, ptr %A.addr.09, align 4
  89   %add.ptr = getelementptr inbounds i32, ptr %A.addr.09, i32 2
  90   %add = add nsw i32 %0, %y
  91   store i32 %add, ptr %B.addr.07, align 4
  92   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.07, i32 1
  93   %inc = add nuw nsw i32 %i.08, 1
  94   %exitcond = icmp eq i32 %inc, 1000
  95   br i1 %exitcond, label %end, label %for.body
  96 end:
  97   ret void
  98 }
  99
 100 define hidden void @pointer_phi_v4i32_add3(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 101 ; CHECK-LABEL: @pointer_phi_v4i32_add3(
 102 ; CHECK-NEXT:  entry:
 103 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 11952
 104 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 3984
 105 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[Y:%.*]], i64 0
 106 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x i32> [[BROADCAST_SPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
 107 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 108 ; CHECK:       vector.body:
 109 ; CHECK-NEXT:    [[POINTER_PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[PTR_IND:%.*]], [[VECTOR_BODY]] ]
 110 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 111 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 0, i32 12, i32 24, i32 36>
 112 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 113 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX]]
 114 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP0]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 115 ; CHECK-NEXT:    [[TMP1:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER]], [[BROADCAST_SPLAT]]
 116 ; CHECK-NEXT:    store <4 x i32> [[TMP1]], ptr [[NEXT_GEP]], align 4
 117 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
 118 ; CHECK-NEXT:    [[PTR_IND]] = getelementptr i8, ptr [[POINTER_PHI]], i32 48
 119 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 996
 120 ; CHECK-NEXT:    br i1 [[TMP2]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP5:![0-9]+]]
 121 ; CHECK:       for.body:
 122 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 123 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 996, [[VECTOR_BODY]] ]
 124 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 125 ; CHECK-NEXT:    [[TMP3:%.*]] = load i32, ptr [[A_ADDR_09]], align 4
 126 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 12
 127 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP3]], [[Y]]
 128 ; CHECK-NEXT:    store i32 [[ADD]], ptr [[B_ADDR_07]], align 4
 129 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 4
 130 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
 131 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 132 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP6:![0-9]+]]
 133 ; CHECK:       end:
 134 ; CHECK-NEXT:    ret void
 135 ;
 136 entry:
 137   br label %for.body
 138 for.body:
 139   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 140   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 141   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 142   %0 = load i32, ptr %A.addr.09, align 4
 143   %add.ptr = getelementptr inbounds i32, ptr %A.addr.09, i32 3
 144   %add = add nsw i32 %0, %y
 145   store i32 %add, ptr %B.addr.07, align 4
 146   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.07, i32 1
 147   %inc = add nuw nsw i32 %i.08, 1
 148   %exitcond = icmp eq i32 %inc, 1000
 149   br i1 %exitcond, label %end, label %for.body
 150 end:
 151   ret void
 152 }
 153
 154 define hidden void @pointer_phi_v8i16_add1(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 155 ; CHECK-LABEL: @pointer_phi_v8i16_add1(
 156 ; CHECK-NEXT:  entry:
 157 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i16
 158 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <8 x i16> poison, i16 [[TMP0]], i64 0
 159 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <8 x i16> [[BROADCAST_SPLATINSERT]], <8 x i16> poison, <8 x i32> zeroinitializer
 160 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 161 ; CHECK:       vector.body:
 162 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 163 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 1
 164 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 [[OFFSET_IDX]]
 165 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 1
 166 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 [[OFFSET_IDX4]]
 167 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <8 x i16>, ptr [[NEXT_GEP]], align 2
 168 ; CHECK-NEXT:    [[TMP1:%.*]] = add <8 x i16> [[WIDE_LOAD]], [[BROADCAST_SPLAT]]
 169 ; CHECK-NEXT:    store <8 x i16> [[TMP1]], ptr [[NEXT_GEP5]], align 2
 170 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 171 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1000
 172 ; CHECK-NEXT:    br i1 [[TMP2]], label [[END:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP7:![0-9]+]]
 173 ; CHECK:       end:
 174 ; CHECK-NEXT:    ret void
 175 ;
 176 entry:
 177   %0 = trunc i32 %y to i16
 178   br label %for.body
 179 for.body:                                         ; preds = %for.body, %for.body.lr.ph
 180   %A.addr.011 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 181   %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 182   %B.addr.09 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 183   %l1 = load i16, ptr %A.addr.011, align 2
 184   %add.ptr = getelementptr inbounds i16, ptr %A.addr.011, i32 1
 185   %conv1 = add i16 %l1, %0
 186   store i16 %conv1, ptr %B.addr.09, align 2
 187   %incdec.ptr = getelementptr inbounds i16, ptr %B.addr.09, i32 1
 188   %inc = add nuw nsw i32 %i.010, 1
 189   %exitcond = icmp eq i32 %inc, 1000
 190   br i1 %exitcond, label %end, label %for.body
 191 end:
 192   ret void
 193 }
 194
 195 define hidden void @pointer_phi_v8i16_add2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 196 ; CHECK-LABEL: @pointer_phi_v8i16_add2(
 197 ; CHECK-NEXT:  entry:
 198 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i16
 199 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 3968
 200 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 1984
 201 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <8 x i16> poison, i16 [[TMP0]], i64 0
 202 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <8 x i16> [[BROADCAST_SPLATINSERT]], <8 x i16> poison, <8 x i32> zeroinitializer
 203 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 204 ; CHECK:       vector.body:
 205 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 206 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 207 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
 208 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 1
 209 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX4]]
 210 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <16 x i16>, ptr [[NEXT_GEP]], align 2
 211 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <16 x i16> [[WIDE_VEC]], <16 x i16> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 212 ; CHECK-NEXT:    [[TMP1:%.*]] = add <8 x i16> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
 213 ; CHECK-NEXT:    store <8 x i16> [[TMP1]], ptr [[NEXT_GEP5]], align 2
 214 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 215 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 992
 216 ; CHECK-NEXT:    br i1 [[TMP2]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP8:![0-9]+]]
 217 ; CHECK:       for.body:
 218 ; CHECK-NEXT:    [[A_ADDR_011:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 219 ; CHECK-NEXT:    [[I_010:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 992, [[VECTOR_BODY]] ]
 220 ; CHECK-NEXT:    [[B_ADDR_09:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 221 ; CHECK-NEXT:    [[L1:%.*]] = load i16, ptr [[A_ADDR_011]], align 2
 222 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_011]], i32 4
 223 ; CHECK-NEXT:    [[CONV1:%.*]] = add i16 [[L1]], [[TMP0]]
 224 ; CHECK-NEXT:    store i16 [[CONV1]], ptr [[B_ADDR_09]], align 2
 225 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_09]], i32 2
 226 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_010]], 1
 227 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 228 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP9:![0-9]+]]
 229 ; CHECK:       end:
 230 ; CHECK-NEXT:    ret void
 231 ;
 232 entry:
 233   %0 = trunc i32 %y to i16
 234   br label %for.body
 235 for.body:                                         ; preds = %for.body, %for.body.lr.ph
 236   %A.addr.011 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 237   %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 238   %B.addr.09 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 239   %l1 = load i16, ptr %A.addr.011, align 2
 240   %add.ptr = getelementptr inbounds i16, ptr %A.addr.011, i32 2
 241   %conv1 = add i16 %l1, %0
 242   store i16 %conv1, ptr %B.addr.09, align 2
 243   %incdec.ptr = getelementptr inbounds i16, ptr %B.addr.09, i32 1
 244   %inc = add nuw nsw i32 %i.010, 1
 245   %exitcond = icmp eq i32 %inc, 1000
 246   br i1 %exitcond, label %end, label %for.body
 247 end:
 248   ret void
 249 }
 250
 251 define hidden void @pointer_phi_v8i16_add3(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 252 ; CHECK-LABEL: @pointer_phi_v8i16_add3(
 253 ; CHECK-NEXT:  entry:
 254 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i16
 255 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 256 ; CHECK:       for.body:
 257 ; CHECK-NEXT:    [[A_ADDR_011:%.*]] = phi ptr [ [[A:%.*]], [[ENTRY:%.*]] ], [ [[ADD_PTR:%.*]], [[FOR_BODY]] ]
 258 ; CHECK-NEXT:    [[I_010:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
 259 ; CHECK-NEXT:    [[B_ADDR_09:%.*]] = phi ptr [ [[B:%.*]], [[ENTRY]] ], [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ]
 260 ; CHECK-NEXT:    [[L1:%.*]] = load i16, ptr [[A_ADDR_011]], align 2
 261 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_011]], i32 6
 262 ; CHECK-NEXT:    [[CONV1:%.*]] = add i16 [[L1]], [[TMP0]]
 263 ; CHECK-NEXT:    store i16 [[CONV1]], ptr [[B_ADDR_09]], align 2
 264 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_09]], i32 2
 265 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_010]], 1
 266 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 267 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]]
 268 ; CHECK:       end:
 269 ; CHECK-NEXT:    ret void
 270 ;
 271 entry:
 272   %0 = trunc i32 %y to i16
 273   br label %for.body
 274 for.body:                                         ; preds = %for.body, %for.body.lr.ph
 275   %A.addr.011 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 276   %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 277   %B.addr.09 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 278   %l1 = load i16, ptr %A.addr.011, align 2
 279   %add.ptr = getelementptr inbounds i16, ptr %A.addr.011, i32 3
 280   %conv1 = add i16 %l1, %0
 281   store i16 %conv1, ptr %B.addr.09, align 2
 282   %incdec.ptr = getelementptr inbounds i16, ptr %B.addr.09, i32 1
 283   %inc = add nuw nsw i32 %i.010, 1
 284   %exitcond = icmp eq i32 %inc, 1000
 285   br i1 %exitcond, label %end, label %for.body
 286 end:
 287   ret void
 288 }
 289
 290 define hidden void @pointer_phi_v16i8_add1(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 291 ; CHECK-LABEL: @pointer_phi_v16i8_add1(
 292 ; CHECK-NEXT:  entry:
 293 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i8
 294 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 992
 295 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 992
 296 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <16 x i8> poison, i8 [[TMP0]], i64 0
 297 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <16 x i8> [[BROADCAST_SPLATINSERT]], <16 x i8> poison, <16 x i32> zeroinitializer
 298 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 299 ; CHECK:       vector.body:
 300 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 301 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[INDEX]]
 302 ; CHECK-NEXT:    [[NEXT_GEP4:%.*]] = getelementptr i8, ptr [[B]], i32 [[INDEX]]
 303 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <16 x i8>, ptr [[NEXT_GEP]], align 1
 304 ; CHECK-NEXT:    [[TMP1:%.*]] = add <16 x i8> [[WIDE_LOAD]], [[BROADCAST_SPLAT]]
 305 ; CHECK-NEXT:    store <16 x i8> [[TMP1]], ptr [[NEXT_GEP4]], align 1
 306 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 16
 307 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 992
 308 ; CHECK-NEXT:    br i1 [[TMP2]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP10:![0-9]+]]
 309 ; CHECK:       for.body:
 310 ; CHECK-NEXT:    [[A_ADDR_010:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 311 ; CHECK-NEXT:    [[I_09:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 992, [[VECTOR_BODY]] ]
 312 ; CHECK-NEXT:    [[B_ADDR_08:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 313 ; CHECK-NEXT:    [[TMP3:%.*]] = load i8, ptr [[A_ADDR_010]], align 1
 314 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_010]], i32 1
 315 ; CHECK-NEXT:    [[CONV1:%.*]] = add i8 [[TMP3]], [[TMP0]]
 316 ; CHECK-NEXT:    store i8 [[CONV1]], ptr [[B_ADDR_08]], align 1
 317 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_08]], i32 1
 318 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_09]], 1
 319 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 320 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP11:![0-9]+]]
 321 ; CHECK:       end:
 322 ; CHECK-NEXT:    ret void
 323 ;
 324 entry:
 325   %0 = trunc i32 %y to i8
 326   br label %for.body
 327
 328 for.body:
 329   %A.addr.010 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 330   %i.09 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 331   %B.addr.08 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 332   %1 = load i8, ptr %A.addr.010, align 1
 333   %add.ptr = getelementptr inbounds i8, ptr %A.addr.010, i32 1
 334   %conv1 = add i8 %1, %0
 335   store i8 %conv1, ptr %B.addr.08, align 1
 336   %incdec.ptr = getelementptr inbounds i8, ptr %B.addr.08, i32 1
 337   %inc = add nuw nsw i32 %i.09, 1
 338   %exitcond = icmp eq i32 %inc, 1000
 339   br i1 %exitcond, label %end, label %for.body
 340 end:
 341   ret void
 342 }
 343
 344 define hidden void @pointer_phi_v16i8_add2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 345 ; CHECK-LABEL: @pointer_phi_v16i8_add2(
 346 ; CHECK-NEXT:  entry:
 347 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i8
 348 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 1984
 349 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 992
 350 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <16 x i8> poison, i8 [[TMP0]], i64 0
 351 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <16 x i8> [[BROADCAST_SPLATINSERT]], <16 x i8> poison, <16 x i32> zeroinitializer
 352 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 353 ; CHECK:       vector.body:
 354 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 355 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 1
 356 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
 357 ; CHECK-NEXT:    [[NEXT_GEP4:%.*]] = getelementptr i8, ptr [[B]], i32 [[INDEX]]
 358 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <32 x i8>, ptr [[NEXT_GEP]], align 1
 359 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <32 x i8> [[WIDE_VEC]], <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
 360 ; CHECK-NEXT:    [[TMP1:%.*]] = add <16 x i8> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
 361 ; CHECK-NEXT:    store <16 x i8> [[TMP1]], ptr [[NEXT_GEP4]], align 1
 362 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 16
 363 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 992
 364 ; CHECK-NEXT:    br i1 [[TMP2]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP12:![0-9]+]]
 365 ; CHECK:       for.body:
 366 ; CHECK-NEXT:    [[A_ADDR_010:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 367 ; CHECK-NEXT:    [[I_09:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 992, [[VECTOR_BODY]] ]
 368 ; CHECK-NEXT:    [[B_ADDR_08:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 369 ; CHECK-NEXT:    [[TMP3:%.*]] = load i8, ptr [[A_ADDR_010]], align 1
 370 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_010]], i32 2
 371 ; CHECK-NEXT:    [[CONV1:%.*]] = add i8 [[TMP3]], [[TMP0]]
 372 ; CHECK-NEXT:    store i8 [[CONV1]], ptr [[B_ADDR_08]], align 1
 373 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_08]], i32 1
 374 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_09]], 1
 375 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 376 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP13:![0-9]+]]
 377 ; CHECK:       end:
 378 ; CHECK-NEXT:    ret void
 379 ;
 380 entry:
 381   %0 = trunc i32 %y to i8
 382   br label %for.body
 383
 384 for.body:
 385   %A.addr.010 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 386   %i.09 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 387   %B.addr.08 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 388   %1 = load i8, ptr %A.addr.010, align 1
 389   %add.ptr = getelementptr inbounds i8, ptr %A.addr.010, i32 2
 390   %conv1 = add i8 %1, %0
 391   store i8 %conv1, ptr %B.addr.08, align 1
 392   %incdec.ptr = getelementptr inbounds i8, ptr %B.addr.08, i32 1
 393   %inc = add nuw nsw i32 %i.09, 1
 394   %exitcond = icmp eq i32 %inc, 1000
 395   br i1 %exitcond, label %end, label %for.body
 396 end:
 397   ret void
 398 }
 399
 400 define hidden void @pointer_phi_v16i8_add3(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %y) {
 401 ; CHECK-LABEL: @pointer_phi_v16i8_add3(
 402 ; CHECK-NEXT:  entry:
 403 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[Y:%.*]] to i8
 404 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 405 ; CHECK:       for.body:
 406 ; CHECK-NEXT:    [[A_ADDR_010:%.*]] = phi ptr [ [[A:%.*]], [[ENTRY:%.*]] ], [ [[ADD_PTR:%.*]], [[FOR_BODY]] ]
 407 ; CHECK-NEXT:    [[I_09:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
 408 ; CHECK-NEXT:    [[B_ADDR_08:%.*]] = phi ptr [ [[B:%.*]], [[ENTRY]] ], [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ]
 409 ; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[A_ADDR_010]], align 1
 410 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_010]], i32 3
 411 ; CHECK-NEXT:    [[CONV1:%.*]] = add i8 [[TMP1]], [[TMP0]]
 412 ; CHECK-NEXT:    store i8 [[CONV1]], ptr [[B_ADDR_08]], align 1
 413 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_08]], i32 1
 414 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_09]], 1
 415 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 416 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]]
 417 ; CHECK:       end:
 418 ; CHECK-NEXT:    ret void
 419 ;
 420 entry:
 421   %0 = trunc i32 %y to i8
 422   br label %for.body
 423
 424 for.body:
 425   %A.addr.010 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 426   %i.09 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 427   %B.addr.08 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 428   %1 = load i8, ptr %A.addr.010, align 1
 429   %add.ptr = getelementptr inbounds i8, ptr %A.addr.010, i32 3
 430   %conv1 = add i8 %1, %0
 431   store i8 %conv1, ptr %B.addr.08, align 1
 432   %incdec.ptr = getelementptr inbounds i8, ptr %B.addr.08, i32 1
 433   %inc = add nuw nsw i32 %i.09, 1
 434   %exitcond = icmp eq i32 %inc, 1000
 435   br i1 %exitcond, label %end, label %for.body
 436 end:
 437   ret void
 438 }
 439
 440 define hidden void @pointer_phi_v4f32_add1(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, float %y) {
 441 ; CHECK-LABEL: @pointer_phi_v4f32_add1(
 442 ; CHECK-NEXT:  entry:
 443 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x float> poison, float [[Y:%.*]], i64 0
 444 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x float> [[BROADCAST_SPLATINSERT]], <4 x float> poison, <4 x i32> zeroinitializer
 445 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 446 ; CHECK:       vector.body:
 447 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 448 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 449 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 [[OFFSET_IDX]]
 450 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 2
 451 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 [[OFFSET_IDX4]]
 452 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <4 x float>, ptr [[NEXT_GEP]], align 4
 453 ; CHECK-NEXT:    [[TMP0:%.*]] = fadd fast <4 x float> [[WIDE_LOAD]], [[BROADCAST_SPLAT]]
 454 ; CHECK-NEXT:    store <4 x float> [[TMP0]], ptr [[NEXT_GEP5]], align 4
 455 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
 456 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1000
 457 ; CHECK-NEXT:    br i1 [[TMP1]], label [[END:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP14:![0-9]+]]
 458 ; CHECK:       end:
 459 ; CHECK-NEXT:    ret void
 460 ;
 461 entry:
 462   br label %for.body
 463 for.body:
 464   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 465   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 466   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 467   %0 = load float, ptr %A.addr.09, align 4
 468   %add.ptr = getelementptr inbounds float, ptr %A.addr.09, i32 1
 469   %add = fadd fast float %0, %y
 470   store float %add, ptr %B.addr.07, align 4
 471   %incdec.ptr = getelementptr inbounds float, ptr %B.addr.07, i32 1
 472   %inc = add nuw nsw i32 %i.08, 1
 473   %exitcond = icmp eq i32 %inc, 1000
 474   br i1 %exitcond, label %end, label %for.body
 475 end:
 476   ret void
 477 }
 478
 479 define hidden void @pointer_phi_v4f32_add2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, float %y) {
 480 ; CHECK-LABEL: @pointer_phi_v4f32_add2(
 481 ; CHECK-NEXT:  entry:
 482 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 7968
 483 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 3984
 484 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x float> poison, float [[Y:%.*]], i64 0
 485 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x float> [[BROADCAST_SPLATINSERT]], <4 x float> poison, <4 x i32> zeroinitializer
 486 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 487 ; CHECK:       vector.body:
 488 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 489 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 3
 490 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
 491 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 2
 492 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX4]]
 493 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <8 x float>, ptr [[NEXT_GEP]], align 4
 494 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <8 x float> [[WIDE_VEC]], <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 495 ; CHECK-NEXT:    [[TMP0:%.*]] = fadd fast <4 x float> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
 496 ; CHECK-NEXT:    store <4 x float> [[TMP0]], ptr [[NEXT_GEP5]], align 4
 497 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
 498 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 996
 499 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP15:![0-9]+]]
 500 ; CHECK:       for.body:
 501 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 502 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 996, [[VECTOR_BODY]] ]
 503 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 504 ; CHECK-NEXT:    [[TMP2:%.*]] = load float, ptr [[A_ADDR_09]], align 4
 505 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 8
 506 ; CHECK-NEXT:    [[ADD:%.*]] = fadd fast float [[TMP2]], [[Y]]
 507 ; CHECK-NEXT:    store float [[ADD]], ptr [[B_ADDR_07]], align 4
 508 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 4
 509 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
 510 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 511 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP16:![0-9]+]]
 512 ; CHECK:       end:
 513 ; CHECK-NEXT:    ret void
 514 ;
 515 entry:
 516   br label %for.body
 517 for.body:
 518   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 519   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 520   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 521   %0 = load float, ptr %A.addr.09, align 4
 522   %add.ptr = getelementptr inbounds float, ptr %A.addr.09, i32 2
 523   %add = fadd fast float %0, %y
 524   store float %add, ptr %B.addr.07, align 4
 525   %incdec.ptr = getelementptr inbounds float, ptr %B.addr.07, i32 1
 526   %inc = add nuw nsw i32 %i.08, 1
 527   %exitcond = icmp eq i32 %inc, 1000
 528   br i1 %exitcond, label %end, label %for.body
 529 end:
 530   ret void
 531 }
 532
 533 define hidden void @pointer_phi_v4f32_add3(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, float %y) {
 534 ; CHECK-LABEL: @pointer_phi_v4f32_add3(
 535 ; CHECK-NEXT:  entry:
 536 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 11952
 537 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 3984
 538 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x float> poison, float [[Y:%.*]], i64 0
 539 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x float> [[BROADCAST_SPLATINSERT]], <4 x float> poison, <4 x i32> zeroinitializer
 540 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 541 ; CHECK:       vector.body:
 542 ; CHECK-NEXT:    [[POINTER_PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[PTR_IND:%.*]], [[VECTOR_BODY]] ]
 543 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 544 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 0, i32 12, i32 24, i32 36>
 545 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 546 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX]]
 547 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER:%.*]] = call <4 x float> @llvm.masked.gather.v4f32.v4p0(<4 x ptr> [[TMP0]], i32 4, <4 x i1> splat (i1 true), <4 x float> poison)
 548 ; CHECK-NEXT:    [[TMP1:%.*]] = fadd fast <4 x float> [[WIDE_MASKED_GATHER]], [[BROADCAST_SPLAT]]
 549 ; CHECK-NEXT:    store <4 x float> [[TMP1]], ptr [[NEXT_GEP]], align 4
 550 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
 551 ; CHECK-NEXT:    [[PTR_IND]] = getelementptr i8, ptr [[POINTER_PHI]], i32 48
 552 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[INDEX_NEXT]], 996
 553 ; CHECK-NEXT:    br i1 [[TMP2]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP17:![0-9]+]]
 554 ; CHECK:       for.body:
 555 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 556 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 996, [[VECTOR_BODY]] ]
 557 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 558 ; CHECK-NEXT:    [[TMP3:%.*]] = load float, ptr [[A_ADDR_09]], align 4
 559 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 12
 560 ; CHECK-NEXT:    [[ADD:%.*]] = fadd fast float [[TMP3]], [[Y]]
 561 ; CHECK-NEXT:    store float [[ADD]], ptr [[B_ADDR_07]], align 4
 562 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 4
 563 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
 564 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 565 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP18:![0-9]+]]
 566 ; CHECK:       end:
 567 ; CHECK-NEXT:    ret void
 568 ;
 569 entry:
 570   br label %for.body
 571 for.body:
 572   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 573   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 574   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 575   %0 = load float, ptr %A.addr.09, align 4
 576   %add.ptr = getelementptr inbounds float, ptr %A.addr.09, i32 3
 577   %add = fadd fast float %0, %y
 578   store float %add, ptr %B.addr.07, align 4
 579   %incdec.ptr = getelementptr inbounds float, ptr %B.addr.07, i32 1
 580   %inc = add nuw nsw i32 %i.08, 1
 581   %exitcond = icmp eq i32 %inc, 1000
 582   br i1 %exitcond, label %end, label %for.body
 583 end:
 584   ret void
 585 }
 586
 587 define hidden void @pointer_phi_v4half_add1(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, half %y) {
 588 ; CHECK-LABEL: @pointer_phi_v4half_add1(
 589 ; CHECK-NEXT:  entry:
 590 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <8 x half> poison, half [[Y:%.*]], i64 0
 591 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <8 x half> [[BROADCAST_SPLATINSERT]], <8 x half> poison, <8 x i32> zeroinitializer
 592 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 593 ; CHECK:       vector.body:
 594 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 595 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 1
 596 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 [[OFFSET_IDX]]
 597 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 1
 598 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 [[OFFSET_IDX4]]
 599 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <8 x half>, ptr [[NEXT_GEP]], align 4
 600 ; CHECK-NEXT:    [[TMP0:%.*]] = fadd fast <8 x half> [[WIDE_LOAD]], [[BROADCAST_SPLAT]]
 601 ; CHECK-NEXT:    store <8 x half> [[TMP0]], ptr [[NEXT_GEP5]], align 4
 602 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 603 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1000
 604 ; CHECK-NEXT:    br i1 [[TMP1]], label [[END:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP19:![0-9]+]]
 605 ; CHECK:       end:
 606 ; CHECK-NEXT:    ret void
 607 ;
 608 entry:
 609   br label %for.body
 610 for.body:
 611   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 612   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 613   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 614   %0 = load half, ptr %A.addr.09, align 4
 615   %add.ptr = getelementptr inbounds half, ptr %A.addr.09, i32 1
 616   %add = fadd fast half %0, %y
 617   store half %add, ptr %B.addr.07, align 4
 618   %incdec.ptr = getelementptr inbounds half, ptr %B.addr.07, i32 1
 619   %inc = add nuw nsw i32 %i.08, 1
 620   %exitcond = icmp eq i32 %inc, 1000
 621   br i1 %exitcond, label %end, label %for.body
 622 end:
 623   ret void
 624 }
 625
 626 define hidden void @pointer_phi_v4half_add2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, half %y) {
 627 ; CHECK-LABEL: @pointer_phi_v4half_add2(
 628 ; CHECK-NEXT:  entry:
 629 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 3968
 630 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 1984
 631 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <8 x half> poison, half [[Y:%.*]], i64 0
 632 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <8 x half> [[BROADCAST_SPLATINSERT]], <8 x half> poison, <8 x i32> zeroinitializer
 633 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 634 ; CHECK:       vector.body:
 635 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 636 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 637 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
 638 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 1
 639 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX4]]
 640 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <16 x half>, ptr [[NEXT_GEP]], align 4
 641 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <16 x half> [[WIDE_VEC]], <16 x half> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 642 ; CHECK-NEXT:    [[TMP0:%.*]] = fadd fast <8 x half> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
 643 ; CHECK-NEXT:    store <8 x half> [[TMP0]], ptr [[NEXT_GEP5]], align 4
 644 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 645 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 992
 646 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP20:![0-9]+]]
 647 ; CHECK:       for.body:
 648 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 649 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 992, [[VECTOR_BODY]] ]
 650 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 651 ; CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[A_ADDR_09]], align 4
 652 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 4
 653 ; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[TMP2]], [[Y]]
 654 ; CHECK-NEXT:    store half [[ADD]], ptr [[B_ADDR_07]], align 4
 655 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 2
 656 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
 657 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 658 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP21:![0-9]+]]
 659 ; CHECK:       end:
 660 ; CHECK-NEXT:    ret void
 661 ;
 662 entry:
 663   br label %for.body
 664 for.body:
 665   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 666   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 667   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 668   %0 = load half, ptr %A.addr.09, align 4
 669   %add.ptr = getelementptr inbounds half, ptr %A.addr.09, i32 2
 670   %add = fadd fast half %0, %y
 671   store half %add, ptr %B.addr.07, align 4
 672   %incdec.ptr = getelementptr inbounds half, ptr %B.addr.07, i32 1
 673   %inc = add nuw nsw i32 %i.08, 1
 674   %exitcond = icmp eq i32 %inc, 1000
 675   br i1 %exitcond, label %end, label %for.body
 676 end:
 677   ret void
 678 }
 679
 680 define hidden void @pointer_phi_v4half_add3(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, half %y) {
 681 ; CHECK-LABEL: @pointer_phi_v4half_add3(
 682 ; CHECK-NEXT:  entry:
 683 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 5952
 684 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 1984
 685 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <8 x half> poison, half [[Y:%.*]], i64 0
 686 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <8 x half> [[BROADCAST_SPLATINSERT]], <8 x half> poison, <8 x i32> zeroinitializer
 687 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 688 ; CHECK:       vector.body:
 689 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 690 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = mul i32 [[INDEX]], 6
 691 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[A]], i32 [[OFFSET_IDX]]
 692 ; CHECK-NEXT:    [[OFFSET_IDX4:%.*]] = shl i32 [[INDEX]], 1
 693 ; CHECK-NEXT:    [[NEXT_GEP5:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX4]]
 694 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <24 x half>, ptr [[NEXT_GEP]], align 4
 695 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <24 x half> [[WIDE_VEC]], <24 x half> poison, <8 x i32> <i32 0, i32 3, i32 6, i32 9, i32 12, i32 15, i32 18, i32 21>
 696 ; CHECK-NEXT:    [[TMP0:%.*]] = fadd fast <8 x half> [[STRIDED_VEC]], [[BROADCAST_SPLAT]]
 697 ; CHECK-NEXT:    store <8 x half> [[TMP0]], ptr [[NEXT_GEP5]], align 4
 698 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 699 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 992
 700 ; CHECK-NEXT:    br i1 [[TMP1]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP22:![0-9]+]]
 701 ; CHECK:       for.body:
 702 ; CHECK-NEXT:    [[A_ADDR_09:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 703 ; CHECK-NEXT:    [[I_08:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 992, [[VECTOR_BODY]] ]
 704 ; CHECK-NEXT:    [[B_ADDR_07:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 705 ; CHECK-NEXT:    [[TMP2:%.*]] = load half, ptr [[A_ADDR_09]], align 4
 706 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_09]], i32 6
 707 ; CHECK-NEXT:    [[ADD:%.*]] = fadd fast half [[TMP2]], [[Y]]
 708 ; CHECK-NEXT:    store half [[ADD]], ptr [[B_ADDR_07]], align 4
 709 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_07]], i32 2
 710 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_08]], 1
 711 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 712 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP23:![0-9]+]]
 713 ; CHECK:       end:
 714 ; CHECK-NEXT:    ret void
 715 ;
 716 entry:
 717   br label %for.body
 718 for.body:
 719   %A.addr.09 = phi ptr [ %add.ptr, %for.body ], [ %A, %entry ]
 720   %i.08 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 721   %B.addr.07 = phi ptr [ %incdec.ptr, %for.body ], [ %B, %entry ]
 722   %0 = load half, ptr %A.addr.09, align 4
 723   %add.ptr = getelementptr inbounds half, ptr %A.addr.09, i32 3
 724   %add = fadd fast half %0, %y
 725   store half %add, ptr %B.addr.07, align 4
 726   %incdec.ptr = getelementptr inbounds half, ptr %B.addr.07, i32 1
 727   %inc = add nuw nsw i32 %i.08, 1
 728   %exitcond = icmp eq i32 %inc, 1000
 729   br i1 %exitcond, label %end, label %for.body
 730 end:
 731   ret void
 732 }
 733
 734 !0 = distinct !{!0, !1}
 735 !1 = !{!"llvm.loop.interleave.count", i32 2}
 736
 737 define hidden void @pointer_phi_v4i32_uf2(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %n, i32 %y) {
 738 ; CHECK-LABEL: @pointer_phi_v4i32_uf2(
 739 ; CHECK-NEXT:  entry:
 740 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 239808
 741 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 39968
 742 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[Y:%.*]], i64 0
 743 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x i32> [[BROADCAST_SPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
 744 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 745 ; CHECK:       vector.body:
 746 ; CHECK-NEXT:    [[POINTER_PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[PTR_IND:%.*]], [[VECTOR_BODY]] ]
 747 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 748 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 0, i32 24, i32 48, i32 72>
 749 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 96, i32 120, i32 144, i32 168>
 750 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 751 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX]]
 752 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP0]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 753 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER5:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP1]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 754 ; CHECK-NEXT:    [[TMP2:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER]], [[BROADCAST_SPLAT]]
 755 ; CHECK-NEXT:    [[TMP3:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER5]], [[BROADCAST_SPLAT]]
 756 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr i8, ptr [[NEXT_GEP]], i32 16
 757 ; CHECK-NEXT:    store <4 x i32> [[TMP2]], ptr [[NEXT_GEP]], align 4
 758 ; CHECK-NEXT:    store <4 x i32> [[TMP3]], ptr [[TMP4]], align 4
 759 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 8
 760 ; CHECK-NEXT:    [[PTR_IND]] = getelementptr i8, ptr [[POINTER_PHI]], i32 192
 761 ; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i32 [[INDEX_NEXT]], 9992
 762 ; CHECK-NEXT:    br i1 [[TMP5]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP24:![0-9]+]]
 763 ; CHECK:       for.cond.cleanup:
 764 ; CHECK-NEXT:    ret void
 765 ; CHECK:       for.body:
 766 ; CHECK-NEXT:    [[A_ADDR_08:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 767 ; CHECK-NEXT:    [[I_07:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 9992, [[VECTOR_BODY]] ]
 768 ; CHECK-NEXT:    [[B_ADDR_06:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 769 ; CHECK-NEXT:    [[TMP6:%.*]] = load i32, ptr [[A_ADDR_08]], align 4
 770 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_08]], i32 24
 771 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP6]], [[Y]]
 772 ; CHECK-NEXT:    store i32 [[ADD]], ptr [[B_ADDR_06]], align 4
 773 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_06]], i32 4
 774 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_07]], 1
 775 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 10000
 776 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP25:![0-9]+]]
 777 ;
 778
 779 entry:
 780   br label %for.body
 781
 782 for.cond.cleanup:
 783   ret void
 784
 785 for.body:
 786   %A.addr.08 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 787   %i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 788   %B.addr.06 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 789   %0 = load i32, ptr %A.addr.08, align 4
 790   %add.ptr = getelementptr inbounds i32, ptr %A.addr.08, i32 6
 791   %add = add nsw i32 %0, %y
 792   store i32 %add, ptr %B.addr.06, align 4
 793   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.06, i32 1
 794   %inc = add nuw nsw i32 %i.07, 1
 795   %exitcond = icmp eq i32 %inc, 10000
 796   br i1 %exitcond, label %for.cond.cleanup, label %for.body, !llvm.loop !0
 797 }
 798
 799 !2 = distinct !{!2, !3}
 800 !3 = !{!"llvm.loop.interleave.count", i32 4}
 801
 802 define hidden void @pointer_phi_v4i32_uf4(ptr noalias nocapture readonly %A, ptr noalias nocapture %B, i32 %n, i32 %y) {
 803 ; CHECK-LABEL: @pointer_phi_v4i32_uf4(
 804 ; CHECK-NEXT:  entry:
 805 ; CHECK-NEXT:    [[IND_END:%.*]] = getelementptr i8, ptr [[A:%.*]], i32 239616
 806 ; CHECK-NEXT:    [[IND_END2:%.*]] = getelementptr i8, ptr [[B:%.*]], i32 39936
 807 ; CHECK-NEXT:    [[BROADCAST_SPLATINSERT:%.*]] = insertelement <4 x i32> poison, i32 [[Y:%.*]], i64 0
 808 ; CHECK-NEXT:    [[BROADCAST_SPLAT:%.*]] = shufflevector <4 x i32> [[BROADCAST_SPLATINSERT]], <4 x i32> poison, <4 x i32> zeroinitializer
 809 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 810 ; CHECK:       vector.body:
 811 ; CHECK-NEXT:    [[POINTER_PHI:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[PTR_IND:%.*]], [[VECTOR_BODY]] ]
 812 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
 813 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 0, i32 24, i32 48, i32 72>
 814 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 96, i32 120, i32 144, i32 168>
 815 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 192, i32 216, i32 240, i32 264>
 816 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 288, i32 312, i32 336, i32 360>
 817 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = shl i32 [[INDEX]], 2
 818 ; CHECK-NEXT:    [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[B]], i32 [[OFFSET_IDX]]
 819 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP0]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 820 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER7:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP1]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 821 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER8:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP2]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 822 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER9:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[TMP3]], i32 4, <4 x i1> splat (i1 true), <4 x i32> poison)
 823 ; CHECK-NEXT:    [[TMP4:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER]], [[BROADCAST_SPLAT]]
 824 ; CHECK-NEXT:    [[TMP5:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER7]], [[BROADCAST_SPLAT]]
 825 ; CHECK-NEXT:    [[TMP6:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER8]], [[BROADCAST_SPLAT]]
 826 ; CHECK-NEXT:    [[TMP7:%.*]] = add nsw <4 x i32> [[WIDE_MASKED_GATHER9]], [[BROADCAST_SPLAT]]
 827 ; CHECK-NEXT:    [[TMP8:%.*]] = getelementptr i8, ptr [[NEXT_GEP]], i32 16
 828 ; CHECK-NEXT:    [[TMP9:%.*]] = getelementptr i8, ptr [[NEXT_GEP]], i32 32
 829 ; CHECK-NEXT:    [[TMP10:%.*]] = getelementptr i8, ptr [[NEXT_GEP]], i32 48
 830 ; CHECK-NEXT:    store <4 x i32> [[TMP4]], ptr [[NEXT_GEP]], align 4
 831 ; CHECK-NEXT:    store <4 x i32> [[TMP5]], ptr [[TMP8]], align 4
 832 ; CHECK-NEXT:    store <4 x i32> [[TMP6]], ptr [[TMP9]], align 4
 833 ; CHECK-NEXT:    store <4 x i32> [[TMP7]], ptr [[TMP10]], align 4
 834 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 16
 835 ; CHECK-NEXT:    [[PTR_IND]] = getelementptr i8, ptr [[POINTER_PHI]], i32 384
 836 ; CHECK-NEXT:    [[TMP11:%.*]] = icmp eq i32 [[INDEX_NEXT]], 9984
 837 ; CHECK-NEXT:    br i1 [[TMP11]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP26:![0-9]+]]
 838 ; CHECK:       for.cond.cleanup:
 839 ; CHECK-NEXT:    ret void
 840 ; CHECK:       for.body:
 841 ; CHECK-NEXT:    [[A_ADDR_08:%.*]] = phi ptr [ [[ADD_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END]], [[VECTOR_BODY]] ]
 842 ; CHECK-NEXT:    [[I_07:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 9984, [[VECTOR_BODY]] ]
 843 ; CHECK-NEXT:    [[B_ADDR_06:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[FOR_BODY]] ], [ [[IND_END2]], [[VECTOR_BODY]] ]
 844 ; CHECK-NEXT:    [[TMP12:%.*]] = load i32, ptr [[A_ADDR_08]], align 4
 845 ; CHECK-NEXT:    [[ADD_PTR]] = getelementptr inbounds nuw i8, ptr [[A_ADDR_08]], i32 24
 846 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP12]], [[Y]]
 847 ; CHECK-NEXT:    store i32 [[ADD]], ptr [[B_ADDR_06]], align 4
 848 ; CHECK-NEXT:    [[INCDEC_PTR]] = getelementptr inbounds nuw i8, ptr [[B_ADDR_06]], i32 4
 849 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_07]], 1
 850 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 10000
 851 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]], !llvm.loop [[LOOP27:![0-9]+]]
 852 ;
 853 entry:
 854   br label %for.body
 855
 856 for.cond.cleanup:
 857   ret void
 858
 859 for.body:
 860   %A.addr.08 = phi ptr [ %A, %entry ], [ %add.ptr, %for.body ]
 861   %i.07 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
 862   %B.addr.06 = phi ptr [ %B, %entry ], [ %incdec.ptr, %for.body ]
 863   %0 = load i32, ptr %A.addr.08, align 4
 864   %add.ptr = getelementptr inbounds i32, ptr %A.addr.08, i32 6
 865   %add = add nsw i32 %0, %y
 866   store i32 %add, ptr %B.addr.06, align 4
 867   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.06, i32 1
 868   %inc = add nuw nsw i32 %i.07, 1
 869   %exitcond = icmp eq i32 %inc, 10000
 870   br i1 %exitcond, label %for.cond.cleanup, label %for.body, !llvm.loop !2
 871 }
 872
 873 define hidden void @mult_ptr_iv(ptr noalias nocapture readonly %x, ptr noalias nocapture %z) {
 874 ; CHECK-LABEL: @mult_ptr_iv(
 875 ; CHECK-NEXT:  entry:
 876 ; CHECK-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, ptr [[Z:%.*]], i32 3000
 877 ; CHECK-NEXT:    [[SCEVGEP1:%.*]] = getelementptr i8, ptr [[X:%.*]], i32 3000
 878 ; CHECK-NEXT:    [[BOUND0:%.*]] = icmp ult ptr [[Z]], [[SCEVGEP1]]
 879 ; CHECK-NEXT:    [[BOUND1:%.*]] = icmp ult ptr [[X]], [[SCEVGEP]]
 880 ; CHECK-NEXT:    [[FOUND_CONFLICT:%.*]] = and i1 [[BOUND0]], [[BOUND1]]
 881 ; CHECK-NEXT:    br i1 [[FOUND_CONFLICT]], label [[FOR_BODY:%.*]], label [[VECTOR_BODY:%.*]]
 882 ; CHECK:       vector.body:
 883 ; CHECK-NEXT:    [[POINTER_PHI:%.*]] = phi ptr [ [[PTR_IND:%.*]], [[VECTOR_BODY]] ], [ [[X]], [[ENTRY:%.*]] ]
 884 ; CHECK-NEXT:    [[POINTER_PHI5:%.*]] = phi ptr [ [[PTR_IND6:%.*]], [[VECTOR_BODY]] ], [ [[Z]], [[ENTRY]] ]
 885 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ], [ 0, [[ENTRY]] ]
 886 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, ptr [[POINTER_PHI]], <4 x i32> <i32 0, i32 3, i32 6, i32 9>
 887 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i8, ptr [[POINTER_PHI5]], <4 x i32> <i32 0, i32 3, i32 6, i32 9>
 888 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i8, <4 x ptr> [[TMP0]], i32 1
 889 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER:%.*]] = call <4 x i8> @llvm.masked.gather.v4i8.v4p0(<4 x ptr> [[TMP0]], i32 1, <4 x i1> splat (i1 true), <4 x i8> poison), !alias.scope [[META28:![0-9]+]]
 890 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8, <4 x ptr> [[TMP0]], i32 2
 891 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER7:%.*]] = call <4 x i8> @llvm.masked.gather.v4i8.v4p0(<4 x ptr> [[TMP2]], i32 1, <4 x i1> splat (i1 true), <4 x i8> poison), !alias.scope [[META28]]
 892 ; CHECK-NEXT:    [[WIDE_MASKED_GATHER8:%.*]] = call <4 x i8> @llvm.masked.gather.v4i8.v4p0(<4 x ptr> [[TMP3]], i32 1, <4 x i1> splat (i1 true), <4 x i8> poison), !alias.scope [[META28]]
 893 ; CHECK-NEXT:    [[TMP4:%.*]] = mul <4 x i8> [[WIDE_MASKED_GATHER]], splat (i8 10)
 894 ; CHECK-NEXT:    [[TMP5:%.*]] = mul <4 x i8> [[WIDE_MASKED_GATHER]], [[WIDE_MASKED_GATHER7]]
 895 ; CHECK-NEXT:    [[TMP6:%.*]] = mul <4 x i8> [[WIDE_MASKED_GATHER]], [[WIDE_MASKED_GATHER8]]
 896 ; CHECK-NEXT:    [[TMP7:%.*]] = getelementptr inbounds i8, <4 x ptr> [[TMP1]], i32 1
 897 ; CHECK-NEXT:    call void @llvm.masked.scatter.v4i8.v4p0(<4 x i8> [[TMP4]], <4 x ptr> [[TMP1]], i32 1, <4 x i1> splat (i1 true)), !alias.scope [[META31:![0-9]+]], !noalias [[META28]]
 898 ; CHECK-NEXT:    [[TMP8:%.*]] = getelementptr inbounds i8, <4 x ptr> [[TMP1]], i32 2
 899 ; CHECK-NEXT:    call void @llvm.masked.scatter.v4i8.v4p0(<4 x i8> [[TMP5]], <4 x ptr> [[TMP7]], i32 1, <4 x i1> splat (i1 true)), !alias.scope [[META31]], !noalias [[META28]]
 900 ; CHECK-NEXT:    call void @llvm.masked.scatter.v4i8.v4p0(<4 x i8> [[TMP6]], <4 x ptr> [[TMP8]], i32 1, <4 x i1> splat (i1 true)), !alias.scope [[META31]], !noalias [[META28]]
 901 ; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
 902 ; CHECK-NEXT:    [[PTR_IND]] = getelementptr i8, ptr [[POINTER_PHI]], i32 12
 903 ; CHECK-NEXT:    [[PTR_IND6]] = getelementptr i8, ptr [[POINTER_PHI5]], i32 12
 904 ; CHECK-NEXT:    [[TMP9:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1000
 905 ; CHECK-NEXT:    br i1 [[TMP9]], label [[END:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP33:![0-9]+]]
 906 ; CHECK:       for.body:
 907 ; CHECK-NEXT:    [[X_ADDR_050:%.*]] = phi ptr [ [[INCDEC_PTR2:%.*]], [[FOR_BODY]] ], [ [[X]], [[ENTRY]] ]
 908 ; CHECK-NEXT:    [[Z_ADDR_049:%.*]] = phi ptr [ [[INCDEC_PTR34:%.*]], [[FOR_BODY]] ], [ [[Z]], [[ENTRY]] ]
 909 ; CHECK-NEXT:    [[I_048:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY]] ]
 910 ; CHECK-NEXT:    [[INCDEC_PTR:%.*]] = getelementptr inbounds nuw i8, ptr [[X_ADDR_050]], i32 1
 911 ; CHECK-NEXT:    [[TMP10:%.*]] = load i8, ptr [[X_ADDR_050]], align 1
 912 ; CHECK-NEXT:    [[INCDEC_PTR1:%.*]] = getelementptr inbounds nuw i8, ptr [[X_ADDR_050]], i32 2
 913 ; CHECK-NEXT:    [[TMP11:%.*]] = load i8, ptr [[INCDEC_PTR]], align 1
 914 ; CHECK-NEXT:    [[INCDEC_PTR2]] = getelementptr inbounds nuw i8, ptr [[X_ADDR_050]], i32 3
 915 ; CHECK-NEXT:    [[TMP12:%.*]] = load i8, ptr [[INCDEC_PTR1]], align 1
 916 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[TMP10]], 10
 917 ; CHECK-NEXT:    [[MUL1:%.*]] = mul i8 [[TMP10]], [[TMP11]]
 918 ; CHECK-NEXT:    [[MUL2:%.*]] = mul i8 [[TMP10]], [[TMP12]]
 919 ; CHECK-NEXT:    [[INCDEC_PTR32:%.*]] = getelementptr inbounds nuw i8, ptr [[Z_ADDR_049]], i32 1
 920 ; CHECK-NEXT:    store i8 [[MUL]], ptr [[Z_ADDR_049]], align 1
 921 ; CHECK-NEXT:    [[INCDEC_PTR33:%.*]] = getelementptr inbounds nuw i8, ptr [[Z_ADDR_049]], i32 2
 922 ; CHECK-NEXT:    store i8 [[MUL1]], ptr [[INCDEC_PTR32]], align 1
 923 ; CHECK-NEXT:    [[INCDEC_PTR34]] = getelementptr inbounds nuw i8, ptr [[Z_ADDR_049]], i32 3
 924 ; CHECK-NEXT:    store i8 [[MUL2]], ptr [[INCDEC_PTR33]], align 1
 925 ; CHECK-NEXT:    [[INC]] = add nuw i32 [[I_048]], 1
 926 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 1000
 927 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[END]], label [[FOR_BODY]], !llvm.loop [[LOOP34:![0-9]+]]
 928 ; CHECK:       end:
 929 ; CHECK-NEXT:    ret void
 930 ;
 931 entry:
 932   br label %for.body
 933
 934 for.body:
 935   %x.addr.050 = phi ptr [ %incdec.ptr2, %for.body ], [ %x, %entry ]
 936   %z.addr.049 = phi ptr [ %incdec.ptr34, %for.body ], [ %z, %entry ]
 937   %i.048 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 938   %incdec.ptr = getelementptr inbounds i8, ptr %x.addr.050, i32 1
 939   %0 = load i8, ptr %x.addr.050, align 1
 940   %incdec.ptr1 = getelementptr inbounds i8, ptr %x.addr.050, i32 2
 941   %1 = load i8, ptr %incdec.ptr, align 1
 942   %incdec.ptr2 = getelementptr inbounds i8, ptr %x.addr.050, i32 3
 943   %2 = load i8, ptr %incdec.ptr1, align 1
 944   %conv = zext i8 %0 to i32
 945   %mul = mul nuw nsw i32 %conv, 10
 946   %conv1 = zext i8 %1 to i32
 947   %conv2 = zext i8 %2 to i32
 948   %mul1 = mul nuw nsw i32 %conv, %conv1
 949   %mul2 = mul nuw nsw i32 %conv, %conv2
 950   %conv3 = trunc i32 %mul to i8
 951   %conv4 = trunc i32 %mul1 to i8
 952   %conv5 = trunc i32 %mul2 to i8
 953   %incdec.ptr32 = getelementptr inbounds i8, ptr %z.addr.049, i32 1
 954   store i8 %conv3, ptr %z.addr.049, align 1
 955   %incdec.ptr33 = getelementptr inbounds i8, ptr %z.addr.049, i32 2
 956   store i8 %conv4, ptr %incdec.ptr32, align 1
 957   %incdec.ptr34 = getelementptr inbounds i8, ptr %z.addr.049, i32 3
 958   store i8 %conv5, ptr %incdec.ptr33, align 1
 959   %inc = add nuw i32 %i.048, 1
 960   %exitcond = icmp eq i32 %inc, 1000
 961   br i1 %exitcond, label %end, label %for.body
 962
 963 end:
 964   ret void
 965 }