llvm/test/Transforms/SLPVectorizer/X86/phi.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=slp-vectorizer,dce -slp-threshold=-100 -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
   3
   4 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32-S128"
   5 target triple = "i386-apple-macosx10.9.0"
   6
   7 ;int foo(ptr A, int k) {
   8 ;  double A0;
   9 ;  double A1;
  10 ;  if (k) {
  11 ;    A0 = 3;
  12 ;    A1 = 5;
  13 ;  } else {
  14 ;    A0 = A[10];
  15 ;    A1 = A[11];
  16 ;  }
  17 ;  A[0] = A0;
  18 ;  A[1] = A1;
  19 ;}
  20
  21
  22 define i32 @foo(ptr nocapture %A, i32 %k) {
  23 ; CHECK-LABEL: @foo(
  24 ; CHECK-NEXT:  entry:
  25 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[K:%.*]], 0
  26 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_ELSE:%.*]], label [[IF_END:%.*]]
  27 ; CHECK:       if.else:
  28 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds double, ptr [[A:%.*]], i64 10
  29 ; CHECK-NEXT:    [[TMP0:%.*]] = load <2 x double>, ptr [[ARRAYIDX]], align 8
  30 ; CHECK-NEXT:    br label [[IF_END]]
  31 ; CHECK:       if.end:
  32 ; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x double> [ [[TMP0]], [[IF_ELSE]] ], [ <double 3.000000e+00, double 5.000000e+00>, [[ENTRY:%.*]] ]
  33 ; CHECK-NEXT:    store <2 x double> [[TMP1]], ptr [[A]], align 8
  34 ; CHECK-NEXT:    ret i32 undef
  35 ;
  36 entry:
  37   %tobool = icmp eq i32 %k, 0
  38   br i1 %tobool, label %if.else, label %if.end
  39
  40 if.else:                                          ; preds = %entry
  41   %arrayidx = getelementptr inbounds double, ptr %A, i64 10
  42   %0 = load double, ptr %arrayidx, align 8
  43   %arrayidx1 = getelementptr inbounds double, ptr %A, i64 11
  44   %1 = load double, ptr %arrayidx1, align 8
  45   br label %if.end
  46
  47 if.end:                                           ; preds = %entry, %if.else
  48   %A0.0 = phi double [ %0, %if.else ], [ 3.000000e+00, %entry ]
  49   %A1.0 = phi double [ %1, %if.else ], [ 5.000000e+00, %entry ]
  50   store double %A0.0, ptr %A, align 8
  51   %arrayidx3 = getelementptr inbounds double, ptr %A, i64 1
  52   store double %A1.0, ptr %arrayidx3, align 8
  53   ret i32 undef
  54 }
  55
  56
  57 ;int foo(ptr restrict B,  ptr restrict A, int n, int m) {
  58 ;  double R=A[1];
  59 ;  double G=A[0];
  60 ;  for (int i=0; i < 100; i++) {
  61 ;    R += 10;
  62 ;    G += 10;
  63 ;    R *= 4;
  64 ;    G *= 4;
  65 ;    R += 4;
  66 ;    G += 4;
  67 ;  }
  68 ;  B[0] = G;
  69 ;  B[1] = R;
  70 ;  return 0;
  71 ;}
  72
  73 define i32 @foo2(ptr noalias nocapture %B, ptr noalias nocapture %A, i32 %n, i32 %m) #0 {
  74 ; CHECK-LABEL: @foo2(
  75 ; CHECK-NEXT:  entry:
  76 ; CHECK-NEXT:    [[TMP0:%.*]] = load <2 x double>, ptr [[A:%.*]], align 8
  77 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
  78 ; CHECK:       for.body:
  79 ; CHECK-NEXT:    [[I_019:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
  80 ; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x double> [ [[TMP0]], [[ENTRY]] ], [ [[TMP4:%.*]], [[FOR_BODY]] ]
  81 ; CHECK-NEXT:    [[TMP2:%.*]] = fadd <2 x double> [[TMP1]], <double 1.000000e+01, double 1.000000e+01>
  82 ; CHECK-NEXT:    [[TMP3:%.*]] = fmul <2 x double> [[TMP2]], <double 4.000000e+00, double 4.000000e+00>
  83 ; CHECK-NEXT:    [[TMP4]] = fadd <2 x double> [[TMP3]], <double 4.000000e+00, double 4.000000e+00>
  84 ; CHECK-NEXT:    [[INC]] = add nsw i32 [[I_019]], 1
  85 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 100
  86 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
  87 ; CHECK:       for.end:
  88 ; CHECK-NEXT:    store <2 x double> [[TMP4]], ptr [[B:%.*]], align 8
  89 ; CHECK-NEXT:    ret i32 0
  90 ;
  91 entry:
  92   %arrayidx = getelementptr inbounds double, ptr %A, i64 1
  93   %0 = load double, ptr %arrayidx, align 8
  94   %1 = load double, ptr %A, align 8
  95   br label %for.body
  96
  97 for.body:                                         ; preds = %for.body, %entry
  98   %i.019 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
  99   %G.018 = phi double [ %1, %entry ], [ %add5, %for.body ]
 100   %R.017 = phi double [ %0, %entry ], [ %add4, %for.body ]
 101   %add = fadd double %R.017, 1.000000e+01
 102   %add2 = fadd double %G.018, 1.000000e+01
 103   %mul = fmul double %add, 4.000000e+00
 104   %mul3 = fmul double %add2, 4.000000e+00
 105   %add4 = fadd double %mul, 4.000000e+00
 106   %add5 = fadd double %mul3, 4.000000e+00
 107   %inc = add nsw i32 %i.019, 1
 108   %exitcond = icmp eq i32 %inc, 100
 109   br i1 %exitcond, label %for.end, label %for.body
 110
 111 for.end:                                          ; preds = %for.body
 112   store double %add5, ptr %B, align 8
 113   %arrayidx7 = getelementptr inbounds double, ptr %B, i64 1
 114   store double %add4, ptr %arrayidx7, align 8
 115   ret i32 0
 116 }
 117
 118 ; float foo3(ptr A) {
 119 ;
 120 ;   float R = A[0];
 121 ;   float G = A[1];
 122 ;   float B = A[2];
 123 ;   float Y = A[3];
 124 ;   float P = A[4];
 125 ;   for (int i=0; i < 121; i+=3) {
 126 ;     R+=Aptr7;
 127 ;     G+=Aptr8;
 128 ;     B+=Aptr9;
 129 ;     Y+=Aptr10;
 130 ;     P+=Aptr11;
 131 ;   }
 132 ;
 133 ;   return R+G+B+Y+P;
 134 ; }
 135
 136 define float @foo3(ptr nocapture readonly %A) #0 {
 137 ; CHECK-LABEL: @foo3(
 138 ; CHECK-NEXT:  entry:
 139 ; CHECK-NEXT:    [[TMP0:%.*]] = load float, ptr [[A:%.*]], align 4
 140 ; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds float, ptr [[A]], i64 1
 141 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[ARRAYIDX1]], align 4
 142 ; CHECK-NEXT:    [[TMP2:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <2 x i32> <i32 poison, i32 0>
 143 ; CHECK-NEXT:    [[TMP3:%.*]] = insertelement <2 x float> [[TMP2]], float [[TMP0]], i32 0
 144 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 145 ; CHECK:       for.body:
 146 ; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
 147 ; CHECK-NEXT:    [[R_052:%.*]] = phi float [ [[TMP0]], [[ENTRY]] ], [ [[ADD6:%.*]], [[FOR_BODY]] ]
 148 ; CHECK-NEXT:    [[TMP4:%.*]] = phi <4 x float> [ [[TMP1]], [[ENTRY]] ], [ [[TMP13:%.*]], [[FOR_BODY]] ]
 149 ; CHECK-NEXT:    [[TMP5:%.*]] = phi <2 x float> [ [[TMP3]], [[ENTRY]] ], [ [[TMP9:%.*]], [[FOR_BODY]] ]
 150 ; CHECK-NEXT:    [[TMP6:%.*]] = extractelement <2 x float> [[TMP5]], i32 0
 151 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[TMP6]], 7.000000e+00
 152 ; CHECK-NEXT:    [[ADD6]] = fadd float [[R_052]], [[MUL]]
 153 ; CHECK-NEXT:    [[TMP7:%.*]] = add nsw i64 [[INDVARS_IV]], 2
 154 ; CHECK-NEXT:    [[ARRAYIDX14:%.*]] = getelementptr inbounds float, ptr [[A]], i64 [[TMP7]]
 155 ; CHECK-NEXT:    [[TMP8:%.*]] = load float, ptr [[ARRAYIDX14]], align 4
 156 ; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 3
 157 ; CHECK-NEXT:    [[ARRAYIDX19:%.*]] = getelementptr inbounds float, ptr [[A]], i64 [[INDVARS_IV_NEXT]]
 158 ; CHECK-NEXT:    [[TMP9]] = load <2 x float>, ptr [[ARRAYIDX19]], align 4
 159 ; CHECK-NEXT:    [[TMP10:%.*]] = shufflevector <2 x float> [[TMP5]], <2 x float> [[TMP9]], <4 x i32> <i32 1, i32 poison, i32 2, i32 3>
 160 ; CHECK-NEXT:    [[TMP11:%.*]] = insertelement <4 x float> [[TMP10]], float [[TMP8]], i32 1
 161 ; CHECK-NEXT:    [[TMP12:%.*]] = fmul <4 x float> [[TMP11]], <float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01>
 162 ; CHECK-NEXT:    [[TMP13]] = fadd <4 x float> [[TMP4]], [[TMP12]]
 163 ; CHECK-NEXT:    [[TMP14:%.*]] = trunc i64 [[INDVARS_IV_NEXT]] to i32
 164 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP14]], 121
 165 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 166 ; CHECK:       for.end:
 167 ; CHECK-NEXT:    [[TMP15:%.*]] = extractelement <4 x float> [[TMP13]], i32 0
 168 ; CHECK-NEXT:    [[ADD28:%.*]] = fadd float [[ADD6]], [[TMP15]]
 169 ; CHECK-NEXT:    [[TMP16:%.*]] = extractelement <4 x float> [[TMP13]], i32 1
 170 ; CHECK-NEXT:    [[ADD29:%.*]] = fadd float [[ADD28]], [[TMP16]]
 171 ; CHECK-NEXT:    [[TMP17:%.*]] = extractelement <4 x float> [[TMP13]], i32 2
 172 ; CHECK-NEXT:    [[ADD30:%.*]] = fadd float [[ADD29]], [[TMP17]]
 173 ; CHECK-NEXT:    [[TMP18:%.*]] = extractelement <4 x float> [[TMP13]], i32 3
 174 ; CHECK-NEXT:    [[ADD31:%.*]] = fadd float [[ADD30]], [[TMP18]]
 175 ; CHECK-NEXT:    ret float [[ADD31]]
 176 ;
 177 entry:
 178   %0 = load float, ptr %A, align 4
 179   %arrayidx1 = getelementptr inbounds float, ptr %A, i64 1
 180   %1 = load float, ptr %arrayidx1, align 4
 181   %arrayidx2 = getelementptr inbounds float, ptr %A, i64 2
 182   %2 = load float, ptr %arrayidx2, align 4
 183   %arrayidx3 = getelementptr inbounds float, ptr %A, i64 3
 184   %3 = load float, ptr %arrayidx3, align 4
 185   %arrayidx4 = getelementptr inbounds float, ptr %A, i64 4
 186   %4 = load float, ptr %arrayidx4, align 4
 187   br label %for.body
 188
 189 for.body:                                         ; preds = %for.body, %entry
 190   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 191   %P.056 = phi float [ %4, %entry ], [ %add26, %for.body ]
 192   %Y.055 = phi float [ %3, %entry ], [ %add21, %for.body ]
 193   %B.054 = phi float [ %2, %entry ], [ %add16, %for.body ]
 194   %G.053 = phi float [ %1, %entry ], [ %add11, %for.body ]
 195   %R.052 = phi float [ %0, %entry ], [ %add6, %for.body ]
 196   %5 = phi float [ %1, %entry ], [ %11, %for.body ]
 197   %6 = phi float [ %0, %entry ], [ %9, %for.body ]
 198   %mul = fmul float %6, 7.000000e+00
 199   %add6 = fadd float %R.052, %mul
 200   %mul10 = fmul float %5, 8.000000e+00
 201   %add11 = fadd float %G.053, %mul10
 202   %7 = add nsw i64 %indvars.iv, 2
 203   %arrayidx14 = getelementptr inbounds float, ptr %A, i64 %7
 204   %8 = load float, ptr %arrayidx14, align 4
 205   %mul15 = fmul float %8, 9.000000e+00
 206   %add16 = fadd float %B.054, %mul15
 207   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3
 208   %arrayidx19 = getelementptr inbounds float, ptr %A, i64 %indvars.iv.next
 209   %9 = load float, ptr %arrayidx19, align 4
 210   %mul20 = fmul float %9, 1.000000e+01
 211   %add21 = fadd float %Y.055, %mul20
 212   %10 = add nsw i64 %indvars.iv, 4
 213   %arrayidx24 = getelementptr inbounds float, ptr %A, i64 %10
 214   %11 = load float, ptr %arrayidx24, align 4
 215   %mul25 = fmul float %11, 1.100000e+01
 216   %add26 = fadd float %P.056, %mul25
 217   %12 = trunc i64 %indvars.iv.next to i32
 218   %cmp = icmp slt i32 %12, 121
 219   br i1 %cmp, label %for.body, label %for.end
 220
 221 for.end:                                          ; preds = %for.body
 222   %add28 = fadd float %add6, %add11
 223   %add29 = fadd float %add28, %add16
 224   %add30 = fadd float %add29, %add21
 225   %add31 = fadd float %add30, %add26
 226   ret float %add31
 227 }
 228
 229 ; Make sure the order of phi nodes of different types does not prevent
 230 ; vectorization of same typed phi nodes.
 231 define float @sort_phi_type(ptr nocapture readonly %A) {
 232 ; CHECK-LABEL: @sort_phi_type(
 233 ; CHECK-NEXT:  entry:
 234 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 235 ; CHECK:       for.body:
 236 ; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
 237 ; CHECK-NEXT:    [[TMP0:%.*]] = phi <4 x float> [ <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>, [[ENTRY]] ], [ [[TMP2:%.*]], [[FOR_BODY]] ]
 238 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <4 x float> [[TMP0]], <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 3, i32 2>
 239 ; CHECK-NEXT:    [[TMP2]] = fmul <4 x float> [[TMP1]], <float 8.000000e+00, float 9.000000e+00, float 1.000000e+02, float 1.110000e+02>
 240 ; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nsw i64 [[INDVARS_IV]], 4
 241 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i64 [[INDVARS_IV_NEXT]], 128
 242 ; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
 243 ; CHECK:       for.end:
 244 ; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <4 x float> [[TMP2]], i32 0
 245 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <4 x float> [[TMP2]], i32 1
 246 ; CHECK-NEXT:    [[ADD29:%.*]] = fadd float [[TMP3]], [[TMP4]]
 247 ; CHECK-NEXT:    [[TMP5:%.*]] = extractelement <4 x float> [[TMP2]], i32 2
 248 ; CHECK-NEXT:    [[ADD30:%.*]] = fadd float [[ADD29]], [[TMP5]]
 249 ; CHECK-NEXT:    [[TMP6:%.*]] = extractelement <4 x float> [[TMP2]], i32 3
 250 ; CHECK-NEXT:    [[ADD31:%.*]] = fadd float [[ADD30]], [[TMP6]]
 251 ; CHECK-NEXT:    ret float [[ADD31]]
 252 ;
 253 entry:
 254   br label %for.body
 255
 256 for.body:                                         ; preds = %for.body, %entry
 257   %Y = phi float [ 1.000000e+01, %entry ], [ %mul10, %for.body ]
 258   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 259   %B = phi float [ 1.000000e+01, %entry ], [ %mul15, %for.body ]
 260   %G = phi float [ 1.000000e+01, %entry ], [ %mul20, %for.body ]
 261   %R = phi float [ 1.000000e+01, %entry ], [ %mul25, %for.body ]
 262   %mul10 = fmul float %Y, 8.000000e+00
 263   %mul15 = fmul float %B, 9.000000e+00
 264   %mul20 = fmul float %R, 10.000000e+01
 265   %mul25 = fmul float %G, 11.100000e+01
 266   %indvars.iv.next = add nsw i64 %indvars.iv, 4
 267   %cmp = icmp slt i64 %indvars.iv.next, 128
 268   br i1 %cmp, label %for.body, label %for.end
 269
 270 for.end:                                          ; preds = %for.body
 271   %add28 = fadd float 1.000000e+01, %mul10
 272   %add29 = fadd float %mul10, %mul15
 273   %add30 = fadd float %add29, %mul20
 274   %add31 = fadd float %add30, %mul25
 275   ret float %add31
 276 }
 277
 278 define void @test(ptr %i1, ptr %i2, ptr %o) {
 279 ; CHECK-LABEL: @test(
 280 ; CHECK-NEXT:  entry:
 281 ; CHECK-NEXT:    [[I1_0:%.*]] = load x86_fp80, ptr [[I1:%.*]], align 16
 282 ; CHECK-NEXT:    [[I1_GEP1:%.*]] = getelementptr x86_fp80, ptr [[I1]], i64 1
 283 ; CHECK-NEXT:    [[I1_1:%.*]] = load x86_fp80, ptr [[I1_GEP1]], align 16
 284 ; CHECK-NEXT:    br i1 undef, label [[THEN:%.*]], label [[END:%.*]]
 285 ; CHECK:       then:
 286 ; CHECK-NEXT:    [[I2_0:%.*]] = load x86_fp80, ptr [[I2:%.*]], align 16
 287 ; CHECK-NEXT:    [[I2_GEP1:%.*]] = getelementptr inbounds x86_fp80, ptr [[I2]], i64 1
 288 ; CHECK-NEXT:    [[I2_1:%.*]] = load x86_fp80, ptr [[I2_GEP1]], align 16
 289 ; CHECK-NEXT:    br label [[END]]
 290 ; CHECK:       end:
 291 ; CHECK-NEXT:    [[PHI0:%.*]] = phi x86_fp80 [ [[I1_0]], [[ENTRY:%.*]] ], [ [[I2_0]], [[THEN]] ]
 292 ; CHECK-NEXT:    [[PHI1:%.*]] = phi x86_fp80 [ [[I1_1]], [[ENTRY]] ], [ [[I2_1]], [[THEN]] ]
 293 ; CHECK-NEXT:    store x86_fp80 [[PHI0]], ptr [[O:%.*]], align 16
 294 ; CHECK-NEXT:    [[O_GEP1:%.*]] = getelementptr inbounds x86_fp80, ptr [[O]], i64 1
 295 ; CHECK-NEXT:    store x86_fp80 [[PHI1]], ptr [[O_GEP1]], align 16
 296 ; CHECK-NEXT:    ret void
 297 ;
 298 ; Test that we correctly recognize the discontiguous memory in arrays where the
 299 ; size is less than the alignment, and through various different GEP formations.
 300 ; We disable the vectorization of x86_fp80 for now.
 301
 302 entry:
 303   %i1.0 = load x86_fp80, ptr %i1, align 16
 304   %i1.gep1 = getelementptr x86_fp80, ptr %i1, i64 1
 305   %i1.1 = load x86_fp80, ptr %i1.gep1, align 16
 306   br i1 undef, label %then, label %end
 307
 308 then:
 309   %i2.0 = load x86_fp80, ptr %i2, align 16
 310   %i2.gep1 = getelementptr inbounds x86_fp80, ptr %i2, i64 1
 311   %i2.1 = load x86_fp80, ptr %i2.gep1, align 16
 312   br label %end
 313
 314 end:
 315   %phi0 = phi x86_fp80 [ %i1.0, %entry ], [ %i2.0, %then ]
 316   %phi1 = phi x86_fp80 [ %i1.1, %entry ], [ %i2.1, %then ]
 317   store x86_fp80 %phi0, ptr %o, align 16
 318   %o.gep1 = getelementptr inbounds x86_fp80, ptr %o, i64 1
 319   store x86_fp80 %phi1, ptr %o.gep1, align 16
 320   ret void
 321 }