test/CodeGen/WinEH/wineh-cloning.ll

   1 ; RUN: opt -mtriple=x86_64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
   2
   3 declare i32 @__CxxFrameHandler3(...)
   4 declare i32 @__C_specific_handler(...)
   5 declare void @ProcessCLRException(...)
   6
   7 declare void @f()
   8
   9 declare void @llvm.foo(i32) nounwind
  10 declare void @llvm.bar() nounwind
  11 declare i32 @llvm.qux() nounwind
  12 declare i1 @llvm.baz() nounwind
  13
  14 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
  15 entry:
  16   ; %x def colors: {entry} subset of use colors; must spill
  17   %x = call i32 @llvm.qux()
  18   invoke void @f()
  19     to label %noreturn unwind label %catch.switch
  20 catch.switch:
  21   %cs = catchswitch within none [label %catch] unwind to caller
  22 catch:
  23   %cp = catchpad within %cs []
  24   br label %noreturn
  25 noreturn:
  26   ; %x use colors: {entry, cleanup}
  27   call void @llvm.foo(i32 %x)
  28   unreachable
  29 }
  30 ; Need two copies of the call to @h, one under entry and one under catch.
  31 ; Currently we generate a load for each, though we shouldn't need one
  32 ; for the use in entry's copy.
  33 ; CHECK-LABEL: define void @test1(
  34 ; CHECK: entry:
  35 ; CHECK:   %x = call i32 @llvm.qux()
  36 ; CHECK:   invoke void @f()
  37 ; CHECK:     to label %[[EntryCopy:[^ ]+]] unwind label %catch
  38 ; CHECK: catch.switch:
  39 ; CHECK:   %cs = catchswitch within none [label %catch] unwind to caller
  40 ; CHECK: catch:
  41 ; CHECK:   catchpad within %cs []
  42 ; CHECK-NEXT: call void @llvm.foo(i32 %x)
  43 ; CHECK: [[EntryCopy]]:
  44 ; CHECK:   call void @llvm.foo(i32 %x)
  45
  46
  47 define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
  48 entry:
  49   invoke void @f()
  50     to label %exit unwind label %cleanup
  51 cleanup:
  52   cleanuppad within none []
  53   br label %exit
  54 exit:
  55   call void @llvm.bar()
  56   ret void
  57 }
  58 ; Need two copies of %exit's call to @f -- the subsequent ret is only
  59 ; valid when coming from %entry, but on the path from %cleanup, this
  60 ; might be a valid call to @f which might dynamically not return.
  61 ; CHECK-LABEL: define void @test2(
  62 ; CHECK: entry:
  63 ; CHECK:   invoke void @f()
  64 ; CHECK:     to label %[[exit:[^ ]+]] unwind label %cleanup
  65 ; CHECK: cleanup:
  66 ; CHECK:   cleanuppad within none []
  67 ; CHECK:   call void @llvm.bar()
  68 ; CHECK-NEXT: unreachable
  69 ; CHECK: [[exit]]:
  70 ; CHECK:   call void @llvm.bar()
  71 ; CHECK-NEXT: ret void
  72
  73
  74 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
  75 entry:
  76   invoke void @f()
  77     to label %invoke.cont unwind label %catch.switch
  78 invoke.cont:
  79   invoke void @f()
  80     to label %exit unwind label %cleanup
  81 catch.switch:
  82   %cs = catchswitch within none [label %catch] unwind to caller
  83 catch:
  84   catchpad within %cs []
  85   br label %shared
  86 cleanup:
  87   cleanuppad within none []
  88   br label %shared
  89 shared:
  90   call void @llvm.bar()
  91   br label %exit
  92 exit:
  93   ret void
  94 }
  95 ; Need two copies of %shared's call to @f (similar to @test2 but
  96 ; the two regions here are siblings, not parent-child).
  97 ; CHECK-LABEL: define void @test3(
  98 ; CHECK:   invoke void @f()
  99 ; CHECK:   invoke void @f()
 100 ; CHECK:     to label %[[exit:[^ ]+]] unwind
 101 ; CHECK: catch:
 102 ; CHECK:   catchpad within %cs []
 103 ; CHECK-NEXT: call void @llvm.bar()
 104 ; CHECK-NEXT: unreachable
 105 ; CHECK: cleanup:
 106 ; CHECK:   cleanuppad within none []
 107 ; CHECK:   call void @llvm.bar()
 108 ; CHECK-NEXT: unreachable
 109 ; CHECK: [[exit]]:
 110 ; CHECK:   ret void
 111
 112
 113 define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
 114 entry:
 115   invoke void @f()
 116     to label %shared unwind label %catch.switch
 117 catch.switch:
 118   %cs = catchswitch within none [label %catch] unwind to caller
 119 catch:
 120   catchpad within %cs []
 121   br label %shared
 122 shared:
 123   %x = call i32 @llvm.qux()
 124   %i = call i32 @llvm.qux()
 125   %zero.trip = icmp eq i32 %i, 0
 126   br i1 %zero.trip, label %exit, label %loop
 127 loop:
 128   %i.loop = phi i32 [ %i, %shared ], [ %i.dec, %loop.tail ]
 129   %b = call i1 @llvm.baz()
 130   br i1 %b, label %left, label %right
 131 left:
 132   %y = call i32 @llvm.qux()
 133   br label %loop.tail
 134 right:
 135   call void @llvm.foo(i32 %x)
 136   br label %loop.tail
 137 loop.tail:
 138   %i.dec = sub i32 %i.loop, 1
 139   %done = icmp eq i32 %i.dec, 0
 140   br i1 %done, label %exit, label %loop
 141 exit:
 142   call void @llvm.foo(i32 %x)
 143   unreachable
 144 }
 145 ; Make sure we can clone regions that have internal control
 146 ; flow and SSA values.  Here we need two copies of everything
 147 ; from %shared to %exit.
 148 ; CHECK-LABEL: define void @test4(
 149 ; CHECK:  entry:
 150 ; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch.switch
 151 ; CHECK:  catch:
 152 ; CHECK:    catchpad within %cs []
 153 ; CHECK:    [[x_C:%[^ ]+]] = call i32 @llvm.qux()
 154 ; CHECK:    [[i_C:%[^ ]+]] = call i32 @llvm.qux()
 155 ; CHECK:    [[zt_C:%[^ ]+]] = icmp eq i32 [[i_C]], 0
 156 ; CHECK:    br i1 [[zt_C]], label %[[exit_C:[^ ]+]], label %[[loop_C:[^ ]+]]
 157 ; CHECK:  [[shared_E]]:
 158 ; CHECK:    [[x_E:%[^ ]+]] = call i32 @llvm.qux()
 159 ; CHECK:    [[i_E:%[^ ]+]] = call i32 @llvm.qux()
 160 ; CHECK:    [[zt_E:%[^ ]+]] = icmp eq i32 [[i_E]], 0
 161 ; CHECK:    br i1 [[zt_E]], label %[[exit_E:[^ ]+]], label %[[loop_E:[^ ]+]]
 162 ; CHECK:  [[loop_C]]:
 163 ; CHECK:    [[iloop_C:%[^ ]+]] = phi i32 [ [[i_C]], %catch ], [ [[idec_C:%[^ ]+]], %[[looptail_C:[^ ]+]] ]
 164 ; CHECK:    [[b_C:%[^ ]+]] = call i1 @llvm.baz()
 165 ; CHECK:    br i1 [[b_C]], label %[[left_C:[^ ]+]], label %[[right_C:[^ ]+]]
 166 ; CHECK:  [[loop_E]]:
 167 ; CHECK:    [[iloop_E:%[^ ]+]] = phi i32 [ [[i_E]], %[[shared_E]] ], [ [[idec_E:%[^ ]+]], %[[looptail_E:[^ ]+]] ]
 168 ; CHECK:    [[b_E:%[^ ]+]] = call i1 @llvm.baz()
 169 ; CHECK:    br i1 [[b_E]], label %[[left_E:[^ ]+]], label %[[right_E:[^ ]+]]
 170 ; CHECK:  [[left_C]]:
 171 ; CHECK:    [[y_C:%[^ ]+]] = call i32 @llvm.qux()
 172 ; CHECK:    br label %[[looptail_C]]
 173 ; CHECK:  [[left_E]]:
 174 ; CHECK:    [[y_E:%[^ ]+]] = call i32 @llvm.qux()
 175 ; CHECK:    br label %[[looptail_E]]
 176 ; CHECK:  [[right_C]]:
 177 ; CHECK:    call void @llvm.foo(i32 [[x_C]])
 178 ; CHECK:    br label %[[looptail_C]]
 179 ; CHECK:  [[right_E]]:
 180 ; CHECK:    call void @llvm.foo(i32 [[x_E]])
 181 ; CHECK:    br label %[[looptail_E]]
 182 ; CHECK:  [[looptail_C]]:
 183 ; CHECK:    [[idec_C]] = sub i32 [[iloop_C]], 1
 184 ; CHECK:    [[done_C:%[^ ]+]] = icmp eq i32 [[idec_C]], 0
 185 ; CHECK:    br i1 [[done_C]], label %[[exit_C]], label %[[loop_C]]
 186 ; CHECK:  [[looptail_E]]:
 187 ; CHECK:    [[idec_E]] = sub i32 [[iloop_E]], 1
 188 ; CHECK:    [[done_E:%[^ ]+]] = icmp eq i32 [[idec_E]], 0
 189 ; CHECK:    br i1 [[done_E]], label %[[exit_E]], label %[[loop_E]]
 190 ; CHECK:  [[exit_C]]:
 191 ; CHECK:    call void @llvm.foo(i32 [[x_C]])
 192 ; CHECK:    unreachable
 193 ; CHECK:  [[exit_E]]:
 194 ; CHECK:    call void @llvm.foo(i32 [[x_E]])
 195 ; CHECK:    unreachable
 196
 197
 198 define void @test5() personality i32 (...)* @__C_specific_handler {
 199 entry:
 200   invoke void @f()
 201     to label %exit unwind label %outer
 202 outer:
 203   %o = cleanuppad within none []
 204   %x = call i32 @llvm.qux()
 205   invoke void @f() [ "funclet"(token %o) ]
 206     to label %outer.ret unwind label %catch.switch
 207 catch.switch:
 208   %cs = catchswitch within %o [label %inner] unwind to caller
 209 inner:
 210   %i = catchpad within %cs []
 211   catchret from %i to label %outer.post-inner
 212 outer.post-inner:
 213   call void @llvm.foo(i32 %x)
 214   br label %outer.ret
 215 outer.ret:
 216   cleanupret from %o unwind to caller
 217 exit:
 218   ret void
 219 }
 220 ; Simple nested case (catch-inside-cleanup).  Nothing needs
 221 ; to be cloned.  The def and use of %x are both in %outer
 222 ; and so don't need to be spilled.
 223 ; CHECK-LABEL: define void @test5(
 224 ; CHECK:      outer:
 225 ; CHECK:        %x = call i32 @llvm.qux()
 226 ; CHECK-NEXT:   invoke void @f()
 227 ; CHECK-NEXT:     to label %outer.ret unwind label %catch.switch
 228 ; CHECK:      inner:
 229 ; CHECK-NEXT:   %i = catchpad within %cs []
 230 ; CHECK-NEXT:   catchret from %i to label %outer.post-inner
 231 ; CHECK:      outer.post-inner:
 232 ; CHECK-NEXT:   call void @llvm.foo(i32 %x)
 233 ; CHECK-NEXT:   br label %outer.ret
 234
 235
 236 define void @test9() personality i32 (...)* @__C_specific_handler {
 237 entry:
 238   invoke void @f()
 239     to label %invoke.cont unwind label %left
 240 invoke.cont:
 241   invoke void @f()
 242     to label %unreachable unwind label %right
 243 left:
 244   %cp.left = cleanuppad within none []
 245   call void @llvm.foo(i32 1)
 246   invoke void @f() [ "funclet"(token %cp.left) ]
 247     to label %unreachable unwind label %right
 248 right:
 249   %cp.right = cleanuppad within none []
 250   call void @llvm.foo(i32 2)
 251   invoke void @f() [ "funclet"(token %cp.right) ]
 252     to label %unreachable unwind label %left
 253 unreachable:
 254   unreachable
 255 }
 256 ; This is an irreducible loop with two funclets that enter each other.
 257 ; CHECK-LABEL: define void @test9(
 258 ; CHECK:     entry:
 259 ; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
 260 ; CHECK:     invoke.cont:
 261 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
 262 ; CHECK:     [[LEFT]]:
 263 ; CHECK:       call void @llvm.foo(i32 1)
 264 ; CHECK:       invoke void @f()
 265 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT]]
 266 ; CHECK:     [[RIGHT]]:
 267 ; CHECK:       call void @llvm.foo(i32 2)
 268 ; CHECK:       invoke void @f()
 269 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT]]
 270 ; CHECK:     [[UNREACHABLE_RIGHT]]:
 271 ; CHECK:       unreachable
 272 ; CHECK:     [[UNREACHABLE_LEFT]]:
 273 ; CHECK:       unreachable
 274 ; CHECK:     [[UNREACHABLE_ENTRY]]:
 275 ; CHECK:       unreachable
 276
 277
 278 define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
 279 entry:
 280   invoke void @f()
 281     to label %unreachable unwind label %inner
 282 inner:
 283   %cleanup = cleanuppad within none []
 284   ; make sure we don't overlook this cleanupret and try to process
 285   ; successor %outer as a child of inner.
 286   cleanupret from %cleanup unwind label %outer
 287 outer:
 288   %cs = catchswitch within none [label %catch.body] unwind to caller
 289
 290 catch.body:
 291   %catch = catchpad within %cs []
 292   catchret from %catch to label %exit
 293 exit:
 294   ret void
 295 unreachable:
 296   unreachable
 297 }
 298 ; CHECK-LABEL: define void @test10(
 299 ; CHECK-NEXT: entry:
 300 ; CHECK-NEXT:   invoke
 301 ; CHECK-NEXT:     to label %unreachable unwind label %inner
 302 ; CHECK:      inner:
 303 ; CHECK-NEXT:   %cleanup = cleanuppad within none []
 304 ; CHECK-NEXT:   cleanupret from %cleanup unwind label %outer
 305 ; CHECK:      outer:
 306 ; CHECK-NEXT:   %cs = catchswitch within none [label %catch.body] unwind to caller
 307 ; CHECK:      catch.body:
 308 ; CHECK-NEXT:   %catch = catchpad within %cs []
 309 ; CHECK-NEXT:   catchret from %catch to label %exit
 310 ; CHECK:      exit:
 311 ; CHECK-NEXT:   ret void
 312
 313 define void @test11() personality i32 (...)* @__C_specific_handler {
 314 entry:
 315   invoke void @f()
 316     to label %exit unwind label %cleanup.outer
 317 cleanup.outer:
 318   %outer = cleanuppad within none []
 319   invoke void @f() [ "funclet"(token %outer) ]
 320     to label %outer.cont unwind label %cleanup.inner
 321 outer.cont:
 322   br label %merge
 323 cleanup.inner:
 324   %inner = cleanuppad within %outer []
 325   br label %merge
 326 merge:
 327   call void @llvm.bar()
 328   unreachable
 329 exit:
 330   ret void
 331 }
 332 ; merge.end will get cloned for outer and inner, but is implausible
 333 ; from inner, so the call @f() in inner's copy of merge should be
 334 ; rewritten to call @f()
 335 ; CHECK-LABEL: define void @test11()
 336 ; CHECK:      %inner = cleanuppad within %outer []
 337 ; CHECK-NEXT: call void @llvm.bar()
 338 ; CHECK-NEXT: unreachable
 339
 340 define void @test12() personality i32 (...)* @__CxxFrameHandler3 !dbg !5 {
 341 entry:
 342   invoke void @f()
 343     to label %cont unwind label %left, !dbg !8
 344 cont:
 345   invoke void @f()
 346     to label %exit unwind label %right
 347 left:
 348   cleanuppad within none []
 349   br label %join
 350 right:
 351   cleanuppad within none []
 352   br label %join
 353 join:
 354   ; This call will get cloned; make sure we can handle cloning
 355   ; instructions with debug metadata attached.
 356   call void @llvm.bar(), !dbg !9
 357   unreachable
 358 exit:
 359   ret void
 360 }
 361
 362 ; CHECK-LABEL: define void @test13()
 363 ; CHECK: ret void
 364 define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
 365 entry:
 366   ret void
 367
 368 unreachable:
 369   cleanuppad within none []
 370   unreachable
 371 }
 372
 373 define void @test14() personality void (...)* @ProcessCLRException {
 374 entry:
 375   invoke void @f()
 376     to label %cont unwind label %cleanup
 377 cont:
 378   invoke void @f()
 379     to label %exit unwind label %switch.outer
 380 cleanup:
 381   %cleanpad = cleanuppad within none []
 382   invoke void @f() [ "funclet" (token %cleanpad) ]
 383     to label %cleanret unwind label %switch.inner
 384 switch.inner:
 385   %cs.inner = catchswitch within %cleanpad [label %pad.inner] unwind to caller
 386 pad.inner:
 387   %cp.inner = catchpad within %cs.inner [i32 1]
 388   catchret from %cp.inner to label %join
 389 cleanret:
 390   cleanupret from %cleanpad unwind to caller
 391 switch.outer:
 392   %cs.outer = catchswitch within none [label %pad.outer] unwind to caller
 393 pad.outer:
 394   %cp.outer = catchpad within %cs.outer [i32 2]
 395   catchret from %cp.outer to label %join
 396 join:
 397   %phi = phi i32 [ 1, %pad.inner ], [ 2, %pad.outer ]
 398   call void @llvm.foo(i32 %phi)
 399   unreachable
 400 exit:
 401   ret void
 402 }
 403 ; Both catchrets target %join, but the catchret from %cp.inner
 404 ; returns to %cleanpad and the catchret from %cp.outer returns to the
 405 ; main function, so %join needs to get cloned and one of the cleanuprets
 406 ; needs to be updated to target the clone
 407 ; CHECK-LABEL: define void @test14()
 408 ; CHECK: catchret from %cp.inner to label %[[Clone1:.+]]
 409 ; CHECK: catchret from %cp.outer to label %[[Clone2:.+]]
 410 ; CHECK: [[Clone1]]:
 411 ; CHECK-NEXT: call void @llvm.foo(i32 1)
 412 ; CHECK-NEXT: unreachable
 413 ; CHECK: [[Clone2]]:
 414 ; CHECK-NEXT: call void @llvm.foo(i32 2)
 415 ; CHECK-NEXT: unreachable
 416
 417 ;; Debug info (from test12)
 418
 419 ; Make sure the DISubprogram doesn't get cloned
 420 ; CHECK-LABEL: !llvm.module.flags
 421 ; CHECK-NOT: !DISubprogram
 422 ; CHECK: !{{[0-9]+}} = distinct !DISubprogram(name: "test12"
 423 ; CHECK-NOT: !DISubprogram
 424 !llvm.module.flags = !{!0}
 425 !llvm.dbg.cu = !{!1}
 426
 427 !0 = !{i32 2, !"Debug Info Version", i32 3}
 428 !1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "compiler", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !3, subprograms: !4)
 429 !2 = !DIFile(filename: "test.cpp", directory: ".")
 430 !3 = !{}
 431 !4 = !{!5}
 432 !5 = distinct !DISubprogram(name: "test12", scope: !2, file: !2, type: !6, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, variables: !3)
 433 !6 = !DISubroutineType(types: !7)
 434 !7 = !{null}
 435 !8 = !DILocation(line: 1, scope: !5)
 436 !9 = !DILocation(line: 2, scope: !5)