test/CodeGen/WebAssembly/cfg-stackify.ll

   1 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
   2
   3 ; Test the CFG stackifier pass.
   4
   5 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
   6 target triple = "wasm32-unknown-unknown"
   7
   8 declare void @something()
   9
  10 ; Test that loops are made contiguous, even in the presence of split backedges.
  11
  12 ; CHECK-LABEL: test0:
  13 ; CHECK: loop
  14 ; CHECK: i32.add
  15 ; CHECK: br_if
  16 ; CHECK: call
  17 ; CHECK: br BB0_1{{$}}
  18 ; CHECK: return{{$}}
  19 define void @test0(i32 %n) {
  20 entry:
  21   br label %header
  22
  23 header:
  24   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
  25   %i.next = add i32 %i, 1
  26
  27   %c = icmp slt i32 %i.next, %n
  28   br i1 %c, label %back, label %exit
  29
  30 exit:
  31   ret void
  32
  33 back:
  34   call void @something()
  35   br label %header
  36 }
  37
  38 ; Same as test0, but the branch condition is reversed.
  39
  40 ; CHECK-LABEL: test1:
  41 ; CHECK: loop
  42 ; CHECK: i32.add
  43 ; CHECK: br_if
  44 ; CHECK: call
  45 ; CHECK: br BB1_1{{$}}
  46 ; CHECK: return{{$}}
  47 define void @test1(i32 %n) {
  48 entry:
  49   br label %header
  50
  51 header:
  52   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
  53   %i.next = add i32 %i, 1
  54
  55   %c = icmp sge i32 %i.next, %n
  56   br i1 %c, label %exit, label %back
  57
  58 exit:
  59   ret void
  60
  61 back:
  62   call void @something()
  63   br label %header
  64 }
  65
  66 ; Test that a simple loop is handled as expected.
  67
  68 ; CHECK-LABEL: test2:
  69 ; CHECK: block BB2_2{{$}}
  70 ; CHECK: br_if {{.*}}, BB2_2{{$}}
  71 ; CHECK: BB2_1:
  72 ; CHECK: br_if $pop{{[0-9]+}}, BB2_1{{$}}
  73 ; CHECK: BB2_2:
  74 ; CHECK: return{{$}}
  75 define void @test2(double* nocapture %p, i32 %n) {
  76 entry:
  77   %cmp.4 = icmp sgt i32 %n, 0
  78   br i1 %cmp.4, label %for.body.preheader, label %for.end
  79
  80 for.body.preheader:
  81   br label %for.body
  82
  83 for.body:
  84   %i.05 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ]
  85   %arrayidx = getelementptr inbounds double, double* %p, i32 %i.05
  86   %0 = load double, double* %arrayidx, align 8
  87   %mul = fmul double %0, 3.200000e+00
  88   store double %mul, double* %arrayidx, align 8
  89   %inc = add nuw nsw i32 %i.05, 1
  90   %exitcond = icmp eq i32 %inc, %n
  91   br i1 %exitcond, label %for.end.loopexit, label %for.body
  92
  93 for.end.loopexit:
  94   br label %for.end
  95
  96 for.end:
  97   ret void
  98 }
  99
 100 ; CHECK-LABEL: doublediamond:
 101 ; CHECK: block BB3_5{{$}}
 102 ; CHECK: block BB3_2{{$}}
 103 ; CHECK: br_if $pop{{[0-9]+}}, BB3_2{{$}}
 104 ; CHECK: block BB3_4{{$}}
 105 ; CHECK: br_if $pop{{[0-9]+}}, BB3_4{{$}}
 106 ; CHECK: br BB3_5{{$}}
 107 ; CHECK: BB3_4:
 108 ; CHECK: BB3_5:
 109 ; CHECK: return ${{[0-9]+}}{{$}}
 110 define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
 111 entry:
 112   %c = icmp eq i32 %a, 0
 113   %d = icmp eq i32 %b, 0
 114   store volatile i32 0, i32* %p
 115   br i1 %c, label %true, label %false
 116 true:
 117   store volatile i32 1, i32* %p
 118   br label %exit
 119 false:
 120   store volatile i32 2, i32* %p
 121   br i1 %d, label %ft, label %ff
 122 ft:
 123   store volatile i32 3, i32* %p
 124   br label %exit
 125 ff:
 126   store volatile i32 4, i32* %p
 127   br label %exit
 128 exit:
 129   store volatile i32 5, i32* %p
 130   ret i32 0
 131 }
 132
 133 ; CHECK-LABEL: triangle:
 134 ; CHECK: block BB4_2{{$}}
 135 ; CHECK: br_if $pop{{[0-9]+}}, BB4_2{{$}}
 136 ; CHECK: BB4_2:
 137 ; CHECK: return ${{[0-9]+}}{{$}}
 138 define i32 @triangle(i32* %p, i32 %a) {
 139 entry:
 140   %c = icmp eq i32 %a, 0
 141   store volatile i32 0, i32* %p
 142   br i1 %c, label %true, label %exit
 143 true:
 144   store volatile i32 1, i32* %p
 145   br label %exit
 146 exit:
 147   store volatile i32 2, i32* %p
 148   ret i32 0
 149 }
 150
 151 ; CHECK-LABEL: diamond:
 152 ; CHECK: block BB5_3{{$}}
 153 ; CHECK: block BB5_2{{$}}
 154 ; CHECK: br_if $pop{{[0-9]+}}, BB5_2{{$}}
 155 ; CHECK: br BB5_3{{$}}
 156 ; CHECK: BB5_2:
 157 ; CHECK: BB5_3:
 158 ; CHECK: return ${{[0-9]+}}{{$}}
 159 define i32 @diamond(i32* %p, i32 %a) {
 160 entry:
 161   %c = icmp eq i32 %a, 0
 162   store volatile i32 0, i32* %p
 163   br i1 %c, label %true, label %false
 164 true:
 165   store volatile i32 1, i32* %p
 166   br label %exit
 167 false:
 168   store volatile i32 2, i32* %p
 169   br label %exit
 170 exit:
 171   store volatile i32 3, i32* %p
 172   ret i32 0
 173 }
 174
 175 ; CHECK-LABEL: single_block:
 176 ; CHECK-NOT: br
 177 ; CHECK: return ${{[0-9]+}}{{$}}
 178 define i32 @single_block(i32* %p) {
 179 entry:
 180   store volatile i32 0, i32* %p
 181   ret i32 0
 182 }
 183
 184 ; CHECK-LABEL: minimal_loop:
 185 ; CHECK-NOT: br
 186 ; CHECK: BB7_1:
 187 ; CHECK: i32.store $0, $pop{{[0-9]+}}{{$}}
 188 ; CHECK: br BB7_1{{$}}
 189 define i32 @minimal_loop(i32* %p) {
 190 entry:
 191   store volatile i32 0, i32* %p
 192   br label %loop
 193 loop:
 194   store volatile i32 1, i32* %p
 195   br label %loop
 196 }
 197
 198 ; CHECK-LABEL: simple_loop:
 199 ; CHECK-NOT: br
 200 ; CHECK: BB8_1:
 201 ; CHECK: loop BB8_2{{$}}
 202 ; CHECK: br_if $pop{{[0-9]+}}, BB8_1{{$}}
 203 ; CHECK: return ${{[0-9]+}}{{$}}
 204 define i32 @simple_loop(i32* %p, i32 %a) {
 205 entry:
 206   %c = icmp eq i32 %a, 0
 207   store volatile i32 0, i32* %p
 208   br label %loop
 209 loop:
 210   store volatile i32 1, i32* %p
 211   br i1 %c, label %loop, label %exit
 212 exit:
 213   store volatile i32 2, i32* %p
 214   ret i32 0
 215 }
 216
 217 ; CHECK-LABEL: doubletriangle:
 218 ; CHECK: block BB9_4{{$}}
 219 ; CHECK: br_if $pop{{[0-9]+}}, BB9_4{{$}}
 220 ; CHECK: block BB9_3{{$}}
 221 ; CHECK: br_if $pop{{[0-9]+}}, BB9_3{{$}}
 222 ; CHECK: BB9_3:
 223 ; CHECK: BB9_4:
 224 ; CHECK: return ${{[0-9]+}}{{$}}
 225 define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
 226 entry:
 227   %c = icmp eq i32 %a, 0
 228   %d = icmp eq i32 %b, 0
 229   store volatile i32 0, i32* %p
 230   br i1 %c, label %true, label %exit
 231 true:
 232   store volatile i32 2, i32* %p
 233   br i1 %d, label %tt, label %tf
 234 tt:
 235   store volatile i32 3, i32* %p
 236   br label %tf
 237 tf:
 238   store volatile i32 4, i32* %p
 239   br label %exit
 240 exit:
 241   store volatile i32 5, i32* %p
 242   ret i32 0
 243 }
 244
 245 ; CHECK-LABEL: ifelse_earlyexits:
 246 ; CHECK: block BB10_4{{$}}
 247 ; CHECK: block BB10_2{{$}}
 248 ; CHECK: br_if $pop{{[0-9]+}}, BB10_2{{$}}
 249 ; CHECK: br BB10_4{{$}}
 250 ; CHECK: BB10_2:
 251 ; CHECK: br_if $pop{{[0-9]+}}, BB10_4{{$}}
 252 ; CHECK: BB10_4:
 253 ; CHECK: return ${{[0-9]+}}{{$}}
 254 define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
 255 entry:
 256   %c = icmp eq i32 %a, 0
 257   %d = icmp eq i32 %b, 0
 258   store volatile i32 0, i32* %p
 259   br i1 %c, label %true, label %false
 260 true:
 261   store volatile i32 1, i32* %p
 262   br label %exit
 263 false:
 264   store volatile i32 2, i32* %p
 265   br i1 %d, label %ft, label %exit
 266 ft:
 267   store volatile i32 3, i32* %p
 268   br label %exit
 269 exit:
 270   store volatile i32 4, i32* %p
 271   ret i32 0
 272 }
 273
 274 ; CHECK-LABEL: doublediamond_in_a_loop:
 275 ; CHECK: BB11_1:
 276 ; CHECK: loop            BB11_7{{$}}
 277 ; CHECK: block           BB11_6{{$}}
 278 ; CHECK: block           BB11_3{{$}}
 279 ; CHECK: br_if           $pop{{.*}}, BB11_3{{$}}
 280 ; CHECK: br              BB11_6{{$}}
 281 ; CHECK: BB11_3:
 282 ; CHECK: block           BB11_5{{$}}
 283 ; CHECK: br_if           $pop{{.*}}, BB11_5{{$}}
 284 ; CHECK: br              BB11_6{{$}}
 285 ; CHECK: BB11_5:
 286 ; CHECK: BB11_6:
 287 ; CHECK: br              BB11_1{{$}}
 288 define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) {
 289 entry:
 290   br label %header
 291 header:
 292   %c = icmp eq i32 %a, 0
 293   %d = icmp eq i32 %b, 0
 294   store volatile i32 0, i32* %p
 295   br i1 %c, label %true, label %false
 296 true:
 297   store volatile i32 1, i32* %p
 298   br label %exit
 299 false:
 300   store volatile i32 2, i32* %p
 301   br i1 %d, label %ft, label %ff
 302 ft:
 303   store volatile i32 3, i32* %p
 304   br label %exit
 305 ff:
 306   store volatile i32 4, i32* %p
 307   br label %exit
 308 exit:
 309   store volatile i32 5, i32* %p
 310   br label %header
 311 }
 312
 313 ; Test that nested loops are handled.
 314
 315 declare void @bar()
 316
 317 define void @test3(i32 %w)  {
 318 entry:
 319   br i1 undef, label %outer.ph, label %exit
 320
 321 outer.ph:
 322   br label %outer
 323
 324 outer:
 325   %tobool = icmp eq i32 undef, 0
 326   br i1 %tobool, label %inner, label %unreachable
 327
 328 unreachable:
 329   unreachable
 330
 331 inner:
 332   %c = icmp eq i32 undef, %w
 333   br i1 %c, label %if.end, label %inner
 334
 335 exit:
 336   ret void
 337
 338 if.end:
 339   call void @bar()
 340   br label %outer
 341 }