test/CodeGen/WebAssembly/cfg-stackify.ll

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