test/Transforms/LoopUnroll/unroll-pragmas.ll

   1 ; RUN: opt < %s -loop-unroll -S | FileCheck %s
   2 ; RUN: opt < %s -loop-unroll -loop-unroll -S | FileCheck %s
   3 ;
   4 ; Run loop unrolling twice to verify that loop unrolling metadata is properly
   5 ; removed and further unrolling is disabled after the pass is run once.
   6
   7 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   8 target triple = "x86_64-unknown-linux-gnu"
   9
  10 ; loop4 contains a small loop which should be completely unrolled by
  11 ; the default unrolling heuristics.  It serves as a control for the
  12 ; unroll(disable) pragma test loop4_with_disable.
  13 ;
  14 ; CHECK-LABEL: @loop4(
  15 ; CHECK-NOT: br i1
  16 define void @loop4(i32* nocapture %a) {
  17 entry:
  18   br label %for.body
  19
  20 for.body:                                         ; preds = %for.body, %entry
  21   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  22   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
  23   %0 = load i32* %arrayidx, align 4
  24   %inc = add nsw i32 %0, 1
  25   store i32 %inc, i32* %arrayidx, align 4
  26   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  27   %exitcond = icmp eq i64 %indvars.iv.next, 4
  28   br i1 %exitcond, label %for.end, label %for.body
  29
  30 for.end:                                          ; preds = %for.body
  31   ret void
  32 }
  33
  34 ; #pragma clang loop unroll(disable)
  35 ;
  36 ; CHECK-LABEL: @loop4_with_disable(
  37 ; CHECK: store i32
  38 ; CHECK-NOT: store i32
  39 ; CHECK: br i1
  40 define void @loop4_with_disable(i32* nocapture %a) {
  41 entry:
  42   br label %for.body
  43
  44 for.body:                                         ; preds = %for.body, %entry
  45   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  46   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
  47   %0 = load i32* %arrayidx, align 4
  48   %inc = add nsw i32 %0, 1
  49   store i32 %inc, i32* %arrayidx, align 4
  50   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  51   %exitcond = icmp eq i64 %indvars.iv.next, 4
  52   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !1
  53
  54 for.end:                                          ; preds = %for.body
  55   ret void
  56 }
  57 !1 = metadata !{metadata !1, metadata !2}
  58 !2 = metadata !{metadata !"llvm.loop.unroll.enable", i1 false}
  59
  60 ; loop64 has a high enough count that it should *not* be unrolled by
  61 ; the default unrolling heuristic.  It serves as the control for the
  62 ; unroll(enable) pragma test loop64_with_.* tests below.
  63 ;
  64 ; CHECK-LABEL: @loop64(
  65 ; CHECK: store i32
  66 ; CHECK-NOT: store i32
  67 ; CHECK: br i1
  68 define void @loop64(i32* nocapture %a) {
  69 entry:
  70   br label %for.body
  71
  72 for.body:                                         ; preds = %for.body, %entry
  73   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  74   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
  75   %0 = load i32* %arrayidx, align 4
  76   %inc = add nsw i32 %0, 1
  77   store i32 %inc, i32* %arrayidx, align 4
  78   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  79   %exitcond = icmp eq i64 %indvars.iv.next, 64
  80   br i1 %exitcond, label %for.end, label %for.body
  81
  82 for.end:                                          ; preds = %for.body
  83   ret void
  84 }
  85
  86 ; #pragma clang loop unroll(enable)
  87 ; Loop should be fully unrolled.
  88 ;
  89 ; CHECK-LABEL: @loop64_with_enable(
  90 ; CHECK-NOT: br i1
  91 define void @loop64_with_enable(i32* nocapture %a) {
  92 entry:
  93   br label %for.body
  94
  95 for.body:                                         ; preds = %for.body, %entry
  96   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  97   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
  98   %0 = load i32* %arrayidx, align 4
  99   %inc = add nsw i32 %0, 1
 100   store i32 %inc, i32* %arrayidx, align 4
 101   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 102   %exitcond = icmp eq i64 %indvars.iv.next, 64
 103   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !3
 104
 105 for.end:                                          ; preds = %for.body
 106   ret void
 107 }
 108 !3 = metadata !{metadata !3, metadata !4}
 109 !4 = metadata !{metadata !"llvm.loop.unroll.enable", i1 true}
 110
 111 ; #pragma clang loop unroll_count(4)
 112 ; Loop should be unrolled 4 times.
 113 ;
 114 ; CHECK-LABEL: @loop64_with_count4(
 115 ; CHECK: store i32
 116 ; CHECK: store i32
 117 ; CHECK: store i32
 118 ; CHECK: store i32
 119 ; CHECK-NOT: store i32
 120 ; CHECK: br i1
 121 define void @loop64_with_count4(i32* nocapture %a) {
 122 entry:
 123   br label %for.body
 124
 125 for.body:                                         ; preds = %for.body, %entry
 126   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 127   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 128   %0 = load i32* %arrayidx, align 4
 129   %inc = add nsw i32 %0, 1
 130   store i32 %inc, i32* %arrayidx, align 4
 131   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 132   %exitcond = icmp eq i64 %indvars.iv.next, 64
 133   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !5
 134
 135 for.end:                                          ; preds = %for.body
 136   ret void
 137 }
 138 !5 = metadata !{metadata !5, metadata !6}
 139 !6 = metadata !{metadata !"llvm.loop.unroll.count", i32 4}
 140
 141
 142 ; #pragma clang loop unroll_count(enable) unroll_count(4)
 143 ; Loop should be unrolled 4 times.
 144 ;
 145 ; CHECK-LABEL: @loop64_with_enable_and_count4(
 146 ; CHECK: store i32
 147 ; CHECK: store i32
 148 ; CHECK: store i32
 149 ; CHECK: store i32
 150 ; CHECK-NOT: store i32
 151 ; CHECK: br i1
 152 define void @loop64_with_enable_and_count4(i32* nocapture %a) {
 153 entry:
 154   br label %for.body
 155
 156 for.body:                                         ; preds = %for.body, %entry
 157   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 158   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 159   %0 = load i32* %arrayidx, align 4
 160   %inc = add nsw i32 %0, 1
 161   store i32 %inc, i32* %arrayidx, align 4
 162   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 163   %exitcond = icmp eq i64 %indvars.iv.next, 64
 164   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !7
 165
 166 for.end:                                          ; preds = %for.body
 167   ret void
 168 }
 169 !7 = metadata !{metadata !7, metadata !6, metadata !4}
 170
 171 ; #pragma clang loop unroll_count(enable)
 172 ; Full unrolling is requested, but loop has a dynamic trip count so
 173 ; no unrolling should occur.
 174 ;
 175 ; CHECK-LABEL: @dynamic_loop_with_enable(
 176 ; CHECK: store i32
 177 ; CHECK-NOT: store i32
 178 ; CHECK: br i1
 179 define void @dynamic_loop_with_enable(i32* nocapture %a, i32 %b) {
 180 entry:
 181   %cmp3 = icmp sgt i32 %b, 0
 182   br i1 %cmp3, label %for.body, label %for.end, !llvm.loop !8
 183
 184 for.body:                                         ; preds = %entry, %for.body
 185   %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
 186   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 187   %0 = load i32* %arrayidx, align 4
 188   %inc = add nsw i32 %0, 1
 189   store i32 %inc, i32* %arrayidx, align 4
 190   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 191   %lftr.wideiv = trunc i64 %indvars.iv.next to i32
 192   %exitcond = icmp eq i32 %lftr.wideiv, %b
 193   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !8
 194
 195 for.end:                                          ; preds = %for.body, %entry
 196   ret void
 197 }
 198 !8 = metadata !{metadata !8, metadata !4}
 199
 200 ; #pragma clang loop unroll_count(4)
 201 ; Loop has a dynamic trip count.  Unrolling should occur, but no
 202 ; conditional branches can be removed.
 203 ;
 204 ; CHECK-LABEL: @dynamic_loop_with_count4(
 205 ; CHECK-NOT: store
 206 ; CHECK: br i1
 207 ; CHECK: store
 208 ; CHECK: br i1
 209 ; CHECK: store
 210 ; CHECK: br i1
 211 ; CHECK: store
 212 ; CHECK: br i1
 213 ; CHECK: store
 214 ; CHECK: br i1
 215 ; CHECK-NOT: br i1
 216 define void @dynamic_loop_with_count4(i32* nocapture %a, i32 %b) {
 217 entry:
 218   %cmp3 = icmp sgt i32 %b, 0
 219   br i1 %cmp3, label %for.body, label %for.end, !llvm.loop !9
 220
 221 for.body:                                         ; preds = %entry, %for.body
 222   %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
 223   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 224   %0 = load i32* %arrayidx, align 4
 225   %inc = add nsw i32 %0, 1
 226   store i32 %inc, i32* %arrayidx, align 4
 227   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 228   %lftr.wideiv = trunc i64 %indvars.iv.next to i32
 229   %exitcond = icmp eq i32 %lftr.wideiv, %b
 230   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !9
 231
 232 for.end:                                          ; preds = %for.body, %entry
 233   ret void
 234 }
 235 !9 = metadata !{metadata !9, metadata !6}
 236
 237 ; #pragma clang loop unroll_count(1)
 238 ; Loop should not be unrolled
 239 ;
 240 ; CHECK-LABEL: @unroll_1(
 241 ; CHECK: store i32
 242 ; CHECK-NOT: store i32
 243 ; CHECK: br i1
 244 define void @unroll_1(i32* nocapture %a, i32 %b) {
 245 entry:
 246   br label %for.body
 247
 248 for.body:                                         ; preds = %for.body, %entry
 249   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 250   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 251   %0 = load i32* %arrayidx, align 4
 252   %inc = add nsw i32 %0, 1
 253   store i32 %inc, i32* %arrayidx, align 4
 254   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 255   %exitcond = icmp eq i64 %indvars.iv.next, 4
 256   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !10
 257
 258 for.end:                                          ; preds = %for.body
 259   ret void
 260 }
 261 !10 = metadata !{metadata !10, metadata !11}
 262 !11 = metadata !{metadata !"llvm.loop.unroll.count", i32 1}
 263
 264 ; #pragma clang loop unroll(enable)
 265 ; Loop has very high loop count (1 million) and full unrolling was requested.
 266 ; Loop should unrolled up to the pragma threshold, but not completely.
 267 ;
 268 ; CHECK-LABEL: @unroll_1M(
 269 ; CHECK: store i32
 270 ; CHECK: store i32
 271 ; CHECK: br i1
 272 define void @unroll_1M(i32* nocapture %a, i32 %b) {
 273 entry:
 274   br label %for.body
 275
 276 for.body:                                         ; preds = %for.body, %entry
 277   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 278   %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
 279   %0 = load i32* %arrayidx, align 4
 280   %inc = add nsw i32 %0, 1
 281   store i32 %inc, i32* %arrayidx, align 4
 282   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
 283   %exitcond = icmp eq i64 %indvars.iv.next, 1000000
 284   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !12
 285
 286 for.end:                                          ; preds = %for.body
 287   ret void
 288 }
 289 !12 = metadata !{metadata !12, metadata !4}