test/CodeGen/X86/wineh-coreclr.ll

   1 ; RUN: llc -mtriple=x86_64-pc-windows-coreclr -verify-machineinstrs < %s | FileCheck %s
   2
   3 declare void @ProcessCLRException()
   4 declare void @f(i32)
   5 declare void @g(i8 addrspace(1)*)
   6 declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
   7
   8 ; Simplified IR for pseudo-C# like the following:
   9 ; void test1() {
  10 ;   try {
  11 ;     f(1);
  12 ;     try {
  13 ;       f(2);
  14 ;     } catch (type1) {
  15 ;       f(3);
  16 ;     } catch (type2) {
  17 ;       f(4);
  18 ;       try {
  19 ;         f(5);
  20 ;       } fault {
  21 ;         f(6);
  22 ;       }
  23 ;     }
  24 ;   } finally {
  25 ;     f(7);
  26 ;   }
  27 ;   f(8);
  28 ; }
  29 ;
  30 ; CHECK-LABEL: test1:     # @test1
  31 ; CHECK-NEXT: [[test1_begin:.*func_begin.*]]:
  32 define void @test1() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
  33 entry:
  34 ; CHECK: # %entry
  35 ; CHECK: leaq [[FPOffset:[0-9]+]](%rsp), %rbp
  36 ; CHECK: .seh_endprologue
  37 ; CHECK: movq %rsp, [[PSPSymOffset:[0-9]+]](%rsp)
  38 ; CHECK: [[test1_before_f1:.+]]:
  39 ; CHECK-NEXT: movl $1, %ecx
  40 ; CHECK-NEXT: callq f
  41 ; CHECK-NEXT: [[test1_after_f1:.+]]:
  42   invoke void @f(i32 1)
  43     to label %inner_try unwind label %finally
  44 inner_try:
  45 ; CHECK: # %inner_try
  46 ; CHECK: [[test1_before_f2:.+]]:
  47 ; CHECK-NEXT: movl $2, %ecx
  48 ; CHECK-NEXT: callq f
  49 ; CHECK-NEXT: [[test1_after_f2:.+]]:
  50   invoke void @f(i32 2)
  51     to label %finally.clone unwind label %exn.dispatch
  52 exn.dispatch:
  53   %catchswitch = catchswitch within none [label %catch1, label %catch2] unwind label %finally
  54 catch1:
  55   %catch.pad1 = catchpad within %catchswitch [i32 1]
  56 ; CHECK: .seh_proc [[test1_catch1:[^ ]+]]
  57 ; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
  58 ;                        ^ all funclets use the same frame size
  59 ; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
  60 ;                              ^ establisher frame pointer passed in rcx
  61 ; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
  62 ; CHECK: leaq [[FPOffset]](%rcx), %rbp
  63 ; CHECK: .seh_endprologue
  64 ; CHECK: movq %rdx, %rcx
  65 ;             ^ exception pointer passed in rdx
  66 ; CHECK-NEXT: callq g
  67   %exn1 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch.pad1)
  68   call void @g(i8 addrspace(1)* %exn1) [ "funclet"(token %catch.pad1) ]
  69 ; CHECK: [[test1_before_f3:.+]]:
  70 ; CHECK-NEXT: movl $3, %ecx
  71 ; CHECK-NEXT: callq f
  72 ; CHECK-NEXT: [[test1_after_f3:.+]]:
  73   invoke void @f(i32 3) [ "funclet"(token %catch.pad1) ]
  74     to label %catch1.ret unwind label %finally
  75 catch1.ret:
  76   catchret from %catch.pad1 to label %finally.clone
  77 catch2:
  78   %catch.pad2 = catchpad within %catchswitch [i32 2]
  79 ; CHECK: .seh_proc [[test1_catch2:[^ ]+]]
  80 ; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
  81 ;                        ^ all funclets use the same frame size
  82 ; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
  83 ;                              ^ establisher frame pointer passed in rcx
  84 ; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
  85 ; CHECK: leaq [[FPOffset]](%rcx), %rbp
  86 ; CHECK: .seh_endprologue
  87 ; CHECK: movq %rdx, %rcx
  88 ;             ^ exception pointer passed in rdx
  89 ; CHECK-NEXT: callq g
  90   %exn2 = call i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token %catch.pad2)
  91   call void @g(i8 addrspace(1)* %exn2) [ "funclet"(token %catch.pad2) ]
  92 ; CHECK: [[test1_before_f4:.+]]:
  93 ; CHECK-NEXT: movl $4, %ecx
  94 ; CHECK-NEXT: callq f
  95 ; CHECK-NEXT: [[test1_after_f4:.+]]:
  96   invoke void @f(i32 4) [ "funclet"(token %catch.pad2) ]
  97     to label %try_in_catch unwind label %finally
  98 try_in_catch:
  99 ; CHECK: # %try_in_catch
 100 ; CHECK: [[test1_before_f5:.+]]:
 101 ; CHECK-NEXT: movl $5, %ecx
 102 ; CHECK-NEXT: callq f
 103 ; CHECK-NEXT: [[test1_after_f5:.+]]:
 104   invoke void @f(i32 5) [ "funclet"(token %catch.pad2) ]
 105     to label %catch2.ret unwind label %fault
 106 fault:
 107 ; CHECK: .seh_proc [[test1_fault:[^ ]+]]
 108   %fault.pad = cleanuppad within %catch.pad2 [i32 undef]
 109 ; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
 110 ;                        ^ all funclets use the same frame size
 111 ; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
 112 ;                              ^ establisher frame pointer passed in rcx
 113 ; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
 114 ; CHECK: leaq [[FPOffset]](%rcx), %rbp
 115 ; CHECK: .seh_endprologue
 116 ; CHECK: [[test1_before_f6:.+]]:
 117 ; CHECK-NEXT: movl $6, %ecx
 118 ; CHECK-NEXT: callq f
 119 ; CHECK-NEXT: [[test1_after_f6:.+]]:
 120   invoke void @f(i32 6) [ "funclet"(token %fault.pad) ]
 121     to label %fault.ret unwind label %finally
 122 fault.ret:
 123   cleanupret from %fault.pad unwind label %finally
 124 catch2.ret:
 125   catchret from %catch.pad2 to label %finally.clone
 126 finally.clone:
 127   call void @f(i32 7)
 128   br label %tail
 129 finally:
 130 ; CHECK: .seh_proc [[test1_finally:[^ ]+]]
 131   %finally.pad = cleanuppad within none []
 132 ; CHECK: .seh_stackalloc [[FuncletFrameSize:[0-9]+]]
 133 ;                        ^ all funclets use the same frame size
 134 ; CHECK: movq [[PSPSymOffset]](%rcx), %rcx
 135 ;                              ^ establisher frame pointer passed in rcx
 136 ; CHECK: movq %rcx, [[PSPSymOffset]](%rsp)
 137 ; CHECK: leaq [[FPOffset]](%rcx), %rbp
 138 ; CHECK: .seh_endprologue
 139 ; CHECK-NEXT: movl $7, %ecx
 140 ; CHECK-NEXT: callq f
 141   call void @f(i32 7) [ "funclet"(token %finally.pad) ]
 142   cleanupret from %finally.pad unwind to caller
 143 tail:
 144   call void @f(i32 8)
 145   ret void
 146 ; CHECK: [[test1_end:.*func_end.*]]:
 147 }
 148
 149 ; Now check for EH table in xdata (following standard xdata)
 150 ; CHECK-LABEL: .section .xdata
 151 ; standard xdata comes here
 152 ; CHECK:      .long 4{{$}}
 153 ;                   ^ number of funclets
 154 ; CHECK-NEXT: .long [[test1_catch1]]-[[test1_begin]]
 155 ;                   ^ offset from L_begin to start of 1st funclet
 156 ; CHECK-NEXT: .long [[test1_catch2]]-[[test1_begin]]
 157 ;                   ^ offset from L_begin to start of 2nd funclet
 158 ; CHECK-NEXT: .long [[test1_fault]]-[[test1_begin]]
 159 ;                   ^ offset from L_begin to start of 3rd funclet
 160 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 161 ;                   ^ offset from L_begin to start of 4th funclet
 162 ; CHECK-NEXT: .long [[test1_end]]-[[test1_begin]]
 163 ;                   ^ offset from L_begin to end of last funclet
 164 ; CHECK-NEXT: .long 7
 165 ;                   ^ number of EH clauses
 166 ; Clause 1: call f(2) is guarded by catch1
 167 ; CHECK-NEXT: .long 0
 168 ;                   ^ flags (0 => catch handler)
 169 ; CHECK-NEXT: .long ([[test1_before_f2]]-[[test1_begin]])+1
 170 ;                   ^ offset of start of clause
 171 ; CHECK-NEXT: .long ([[test1_after_f2]]-[[test1_begin]])+1
 172 ;                   ^ offset of end of clause
 173 ; CHECK-NEXT: .long [[test1_catch1]]-[[test1_begin]]
 174 ;                   ^ offset of start of handler
 175 ; CHECK-NEXT: .long [[test1_catch2]]-[[test1_begin]]
 176 ;                   ^ offset of end of handler
 177 ; CHECK-NEXT: .long 1
 178 ;                   ^ type token of catch (from catchpad)
 179 ; Clause 2: call f(2) is also guarded by catch2
 180 ; CHECK-NEXT: .long 0
 181 ;                   ^ flags (0 => catch handler)
 182 ; CHECK-NEXT: .long ([[test1_before_f2]]-[[test1_begin]])+1
 183 ;                   ^ offset of start of clause
 184 ; CHECK-NEXT: .long ([[test1_after_f2]]-[[test1_begin]])+1
 185 ;                   ^ offset of end of clause
 186 ; CHECK-NEXT: .long [[test1_catch2]]-[[test1_begin]]
 187 ;                   ^ offset of start of handler
 188 ; CHECK-NEXT: .long [[test1_fault]]-[[test1_begin]]
 189 ;                   ^ offset of end of handler
 190 ; CHECK-NEXT: .long 2
 191 ;                   ^ type token of catch (from catchpad)
 192 ; Clause 3: calls f(1) and f(2) are guarded by finally
 193 ; CHECK-NEXT: .long 2
 194 ;                   ^ flags (2 => finally handler)
 195 ; CHECK-NEXT: .long ([[test1_before_f1]]-[[test1_begin]])+1
 196 ;                   ^ offset of start of clause
 197 ; CHECK-NEXT: .long ([[test1_after_f2]]-[[test1_begin]])+1
 198 ;                   ^ offset of end of clause
 199 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 200 ;                   ^ offset of start of handler
 201 ; CHECK-NEXT: .long [[test1_end]]-[[test1_begin]]
 202 ;                   ^ offset of end of handler
 203 ; CHECK-NEXT: .long 0
 204 ;                   ^ type token slot (null for finally)
 205 ; Clause 4: call f(3) is guarded by finally
 206 ;           This is a "duplicate" because the protected range (f(3))
 207 ;           is in funclet catch1 but the finally's immediate parent
 208 ;           is the main function, not that funclet.
 209 ; CHECK-NEXT: .long 10
 210 ;                   ^ flags (2 => finally handler | 8 => duplicate)
 211 ; CHECK-NEXT: .long ([[test1_before_f3]]-[[test1_begin]])+1
 212 ;                   ^ offset of start of clause
 213 ; CHECK-NEXT: .long ([[test1_after_f3]]-[[test1_begin]])+1
 214 ;                   ^ offset of end of clause
 215 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 216 ;                   ^ offset of start of handler
 217 ; CHECK-NEXT: .long [[test1_end]]-[[test1_begin]]
 218 ;                   ^ offset of end of handler
 219 ; CHECK-NEXT: .long 0
 220 ;                   ^ type token slot (null for finally)
 221 ; Clause 5: call f(5) is guarded by fault
 222 ; CHECK-NEXT: .long 4
 223 ;                   ^ flags (4 => fault handler)
 224 ; CHECK-NEXT: .long ([[test1_before_f5]]-[[test1_begin]])+1
 225 ;                   ^ offset of start of clause
 226 ; CHECK-NEXT: .long ([[test1_after_f5]]-[[test1_begin]])+1
 227 ;                   ^ offset of end of clause
 228 ; CHECK-NEXT: .long [[test1_fault]]-[[test1_begin]]
 229 ;                   ^ offset of start of handler
 230 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 231 ;                   ^ offset of end of handler
 232 ; CHECK-NEXT: .long 0
 233 ;                   ^ type token slot (null for fault)
 234 ; Clause 6: calls f(4) and f(5) are guarded by finally
 235 ;           This is a "duplicate" because the protected range (f(4)-f(5))
 236 ;           is in funclet catch2 but the finally's immediate parent
 237 ;           is the main function, not that funclet.
 238 ; CHECK-NEXT: .long 10
 239 ;                   ^ flags (2 => finally handler | 8 => duplicate)
 240 ; CHECK-NEXT: .long ([[test1_before_f4]]-[[test1_begin]])+1
 241 ;                   ^ offset of start of clause
 242 ; CHECK-NEXT: .long ([[test1_after_f5]]-[[test1_begin]])+1
 243 ;                   ^ offset of end of clause
 244 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 245 ;                   ^ offset of start of handler
 246 ; CHECK-NEXT: .long [[test1_end]]-[[test1_begin]]
 247 ;                   ^ offset of end of handler
 248 ; CHECK-NEXT: .long 0
 249 ;                   ^ type token slot (null for finally)
 250 ; Clause 7: call f(6) is guarded by finally
 251 ;           This is a "duplicate" because the protected range (f(3))
 252 ;           is in funclet catch1 but the finally's immediate parent
 253 ;           is the main function, not that funclet.
 254 ; CHECK-NEXT: .long 10
 255 ;                   ^ flags (2 => finally handler | 8 => duplicate)
 256 ; CHECK-NEXT: .long ([[test1_before_f6]]-[[test1_begin]])+1
 257 ;                   ^ offset of start of clause
 258 ; CHECK-NEXT: .long ([[test1_after_f6]]-[[test1_begin]])+1
 259 ;                   ^ offset of end of clause
 260 ; CHECK-NEXT: .long [[test1_finally]]-[[test1_begin]]
 261 ;                   ^ offset of start of handler
 262 ; CHECK-NEXT: .long [[test1_end]]-[[test1_begin]]
 263 ;                   ^ offset of end of handler
 264 ; CHECK-NEXT: .long 0
 265 ;                   ^ type token slot (null for finally)
 266
 267 ; Test with a cleanup that has no cleanupret, and thus needs its unwind dest
 268 ; inferred from an inner catchswitch
 269 ;
 270 ; corresponds to C# along the lines of:
 271 ; void test2() {
 272 ;   try {
 273 ;     try {
 274 ;       f(1);
 275 ;     } fault {
 276 ;       try {
 277 ;         f(2);
 278 ;       } catch(type1) {
 279 ;       }
 280 ;       __unreachable();
 281 ;     }
 282 ;   } catch(type2) {
 283 ;   }
 284 ; }
 285 ;
 286 define void @test2() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
 287 entry:
 288   invoke void @f(i32 1)
 289     to label %exit unwind label %fault
 290 fault:
 291   %fault.pad = cleanuppad within none [i32 undef]
 292   invoke void @f(i32 2) ["funclet"(token %fault.pad)]
 293     to label %unreachable unwind label %exn.dispatch.inner
 294 exn.dispatch.inner:
 295   %catchswitch.inner = catchswitch within %fault.pad [label %catch1] unwind label %exn.dispatch.outer
 296 catch1:
 297   %catch.pad1 = catchpad within %catchswitch.inner [i32 1]
 298   catchret from %catch.pad1 to label %unreachable
 299 exn.dispatch.outer:
 300   %catchswitch.outer = catchswitch within none [label %catch2] unwind to caller
 301 catch2:
 302   %catch.pad2 = catchpad within %catchswitch.outer [i32 2]
 303   catchret from %catch.pad2 to label %exit
 304 exit:
 305   ret void
 306 unreachable:
 307   unreachable
 308 }
 309 ; CHECK-LABEL: test2:     # @test2
 310 ; CHECK-NEXT: [[test2_begin:.*func_begin.*]]:
 311 ; CHECK: .seh_endprologue
 312 ; CHECK: [[test2_before_f1:.+]]:
 313 ; CHECK-NEXT: movl $1, %ecx
 314 ; CHECK-NEXT: callq f
 315 ; CHECK-NEXT: [[test2_after_f1:.+]]:
 316 ; CHECK: .seh_proc [[test2_catch1:[^ ]+]]
 317 ; CHECK: .seh_proc [[test2_catch2:[^ ]+]]
 318 ; CHECK: .seh_proc [[test2_fault:[^ ]+]]
 319 ; CHECK: .seh_endprologue
 320 ; CHECK: [[test2_before_f2:.+]]:
 321 ; CHECK-NEXT: movl $2, %ecx
 322 ; CHECK-NEXT: callq f
 323 ; CHECK-NEXT: [[test2_after_f2:.+]]:
 324 ; CHECK: [[test2_end:.*func_end.*]]:
 325
 326
 327 ; Now check for EH table in xdata (following standard xdata)
 328 ; CHECK-LABEL: .section .xdata
 329 ; standard xdata comes here
 330 ; CHECK:      .long 3{{$}}
 331 ;                   ^ number of funclets
 332 ; CHECK-NEXT: .long [[test2_catch1]]-[[test2_begin]]
 333 ;                   ^ offset from L_begin to start of 2nd funclet
 334 ; CHECK-NEXT: .long [[test2_catch2]]-[[test2_begin]]
 335 ;                   ^ offset from L_begin to start of 3rd funclet
 336 ; CHECK-NEXT: .long [[test2_fault]]-[[test2_begin]]
 337 ;                   ^ offset from L_begin to start of 1st funclet
 338 ; CHECK-NEXT: .long [[test2_end]]-[[test2_begin]]
 339 ;                   ^ offset from L_begin to end of last funclet
 340 ; CHECK-NEXT: .long 4
 341 ;                   ^ number of EH clauses
 342 ; Clause 1: call f(1) is guarded by fault
 343 ; CHECK-NEXT: .long 4
 344 ;                   ^ flags (4 => fault handler)
 345 ; CHECK-NEXT: .long ([[test2_before_f1]]-[[test2_begin]])+1
 346 ;                   ^ offset of start of clause
 347 ; CHECK-NEXT: .long ([[test2_after_f1]]-[[test2_begin]])+1
 348 ;                   ^ offset of end of clause
 349 ; CHECK-NEXT: .long [[test2_fault]]-[[test2_begin]]
 350 ;                   ^ offset of start of handler
 351 ; CHECK-NEXT: .long [[test2_end]]-[[test2_begin]]
 352 ;                   ^ offset of end of handler
 353 ; CHECK-NEXT: .long 0
 354 ;                   ^ type token slot (null for fault)
 355 ; Clause 2: call f(1) is also guarded by catch2
 356 ; CHECK-NEXT: .long 0
 357 ;                   ^ flags (0 => catch handler)
 358 ; CHECK-NEXT: .long ([[test2_before_f1]]-[[test2_begin]])+1
 359 ;                   ^ offset of start of clause
 360 ; CHECK-NEXT: .long ([[test2_after_f1]]-[[test2_begin]])+1
 361 ;                   ^ offset of end of clause
 362 ; CHECK-NEXT: .long [[test2_catch2]]-[[test2_begin]]
 363 ;                   ^ offset of start of handler
 364 ; CHECK-NEXT: .long [[test2_fault]]-[[test2_begin]]
 365 ;                   ^ offset of end of handler
 366 ; CHECK-NEXT: .long 2
 367 ;                   ^ type token of catch (from catchpad)
 368 ; Clause 3: calls f(2) is guarded by catch1
 369 ; CHECK-NEXT: .long 0
 370 ;                   ^ flags (0 => catch handler)
 371 ; CHECK-NEXT: .long ([[test2_before_f2]]-[[test2_begin]])+1
 372 ;                   ^ offset of start of clause
 373 ; CHECK-NEXT: .long ([[test2_after_f2]]-[[test2_begin]])+1
 374 ;                   ^ offset of end of clause
 375 ; CHECK-NEXT: .long [[test2_catch1]]-[[test2_begin]]
 376 ;                   ^ offset of start of handler
 377 ; CHECK-NEXT: .long [[test2_catch2]]-[[test2_begin]]
 378 ;                   ^ offset of end of handler
 379 ; CHECK-NEXT: .long 1
 380 ;                   ^ type token of catch (from catchpad)
 381 ; Clause 4: call f(2) is also guarded by catch2
 382 ;           This is a "duplicate" because the protected range (f(2))
 383 ;           is in funclet fault but catch2's immediate parent
 384 ;           is the main function, not that funclet.
 385 ; CHECK-NEXT: .long 8
 386 ;                   ^ flags (0 => catch handler | 8 => duplicate)
 387 ; CHECK-NEXT: .long ([[test2_before_f2]]-[[test2_begin]])+1
 388 ;                   ^ offset of start of clause
 389 ; CHECK-NEXT: .long ([[test2_after_f2]]-[[test2_begin]])+1
 390 ;                   ^ offset of end of clause
 391 ; CHECK-NEXT: .long [[test2_catch2]]-[[test2_begin]]
 392 ;                   ^ offset of start of handler
 393 ; CHECK-NEXT: .long [[test2_fault]]-[[test2_begin]]
 394 ;                   ^ offset of end of handler
 395 ; CHECK-NEXT: .long 2
 396 ;                   ^ type token of catch (from catchpad)
 397
 398 ; Test with several cleanups that need to infer their unwind dests from each
 399 ; other, the inner one needing to make the inference from an invoke, ignoring
 400 ; not-really-unwinding calls/unwind-to-caller catchswitches, as well as some
 401 ; internal invokes/catchswitches
 402 ;
 403 ; Corresponds to something like:
 404 ; void test3() {
 405 ;   try {
 406 ;     f(1);
 407 ;   } fault { // fault1
 408 ;     try {
 409 ;       try {
 410 ;         f(2);
 411 ;         __unreachable();
 412 ;       } fault { // fault2
 413 ;         try {
 414 ;           f(3);
 415 ;         } fault { // fault3
 416 ;           try {
 417 ;             f(4);
 418 ;           } fault { // fault4
 419 ;             f(5); // no unwind edge (e.g. front-end knew it wouldn't throw but
 420 ;                    didn't bother to specify nounwind)
 421 ;             try {
 422 ;               try {
 423 ;                 f(6);
 424 ;               } catch(type 1) {
 425 ;                 goto __unreachable;
 426 ;               }
 427 ;             } catch (type 2) { // marked "unwinds to caller" because we allow
 428 ;                                // that if the unwind won't be taken (see
 429 ;                                // SimplifyUnreachable & RemoveUnwindEdge)
 430 ;               goto _unreachable;
 431 ;             }
 432 ;             f(7);
 433 ;             __unreachable();
 434 ;           }
 435 ;         }
 436 ;       }
 437 ;     } fault { // fault 5
 438 ;     }
 439 ;   }
 440 ; }
 441 ;
 442 ; CHECK-LABEL: test3:     # @test3
 443 ; CHECK-NEXT: [[test3_begin:.*func_begin.*]]:
 444 define void @test3() personality i8* bitcast (void ()* @ProcessCLRException to i8*) {
 445 entry:
 446 ; CHECK: .seh_endprologue
 447 ; CHECK: [[test3_before_f1:.+]]:
 448 ; CHECK-NEXT: movl $1, %ecx
 449 ; CHECK-NEXT: callq f
 450 ; CHECK-NEXT: [[test3_after_f1:.+]]:
 451   invoke void @f(i32 1)
 452     to label %exit unwind label %fault1
 453 fault1:
 454  ; check lines below since this gets reordered to end-of-func
 455   %fault.pad1 = cleanuppad within none [i32 undef]
 456   invoke void @f(i32 2) ["funclet"(token %fault.pad1)]
 457     to label %unreachable unwind label %fault2
 458 fault2:
 459  ; check lines below since this gets reordered to end-of-func
 460   %fault.pad2 = cleanuppad within %fault.pad1 [i32 undef]
 461   invoke void @f(i32 3) ["funclet"(token %fault.pad2)]
 462     to label %unreachable unwind label %fault3
 463 fault3:
 464  ; check lines below since this gets reordered to end-of-func
 465   %fault.pad3 = cleanuppad within %fault.pad2 [i32 undef]
 466   invoke void @f(i32 4) ["funclet"(token %fault.pad3)]
 467     to label %unreachable unwind label %fault4
 468 fault4:
 469 ; CHECK: .seh_proc [[test3_fault4:[^ ]+]]
 470   %fault.pad4 = cleanuppad within %fault.pad3 [i32 undef]
 471 ; CHECK: .seh_endprologue
 472   call void @f(i32 5) ["funclet"(token %fault.pad4)]
 473 ; CHECK: [[test3_before_f6:.+]]:
 474 ; CHECK-NEXT: movl $6, %ecx
 475 ; CHECK-NEXT: callq f
 476 ; CHECK-NEXT: [[test3_after_f6:.+]]:
 477   invoke void @f(i32 6) ["funclet"(token %fault.pad4)]
 478     to label %fault4.cont unwind label %exn.dispatch1
 479 fault4.cont:
 480 ; CHECK: # %fault4.cont
 481 ; CHECK: [[test3_before_f7:.+]]:
 482 ; CHECK-NEXT: movl $7, %ecx
 483 ; CHECK-NEXT: callq f
 484 ; CHECK-NEXT: [[test3_after_f7:.+]]:
 485   invoke void @f(i32 7) ["funclet"(token %fault.pad4)]
 486     to label %unreachable unwind label %fault5
 487 exn.dispatch1:
 488   %catchswitch1 = catchswitch within %fault.pad4 [label %catch1] unwind label %exn.dispatch2
 489 catch1:
 490   %catch.pad1 = catchpad within %catchswitch1 [i32 1]
 491 ; CHECK: .seh_proc [[test3_catch1:[^ ]+]]
 492   catchret from %catch.pad1 to label %unreachable
 493 exn.dispatch2:
 494   %catchswitch2 = catchswitch within %fault.pad4 [label %catch2] unwind to caller
 495 catch2:
 496   %catch.pad2 = catchpad within %catchswitch2 [i32 2]
 497 ; CHECK: .seh_proc [[test3_catch2:[^ ]+]]
 498   catchret from %catch.pad2 to label %unreachable
 499 fault5:
 500 ; CHECK: .seh_proc [[test3_fault5:[^ ]+]]
 501   %fault.pad5 = cleanuppad within %fault.pad1 [i32 undef]
 502 ; CHECK: .seh_endprologue
 503 cleanupret from %fault.pad5 unwind to caller
 504 exit:
 505   ret void
 506 unreachable:
 507   unreachable
 508 ; CHECK: .seh_proc [[test3_fault3:[^ ]+]]
 509 ; CHECK: # %fault3
 510 ; CHECK: .seh_endprologue
 511 ; CHECK: [[test3_before_f4:.+]]:
 512 ; CHECK-NEXT: movl $4, %ecx
 513 ; CHECK-NEXT: callq f
 514 ; CHECK-NEXT: [[test3_after_f4:.+]]:
 515 ; CHECK: .seh_proc [[test3_fault2:[^ ]+]]
 516 ; CHECK: # %fault2
 517 ; CHECK: .seh_endprologue
 518 ; CHECK: [[test3_before_f3:.+]]:
 519 ; CHECK-NEXT: movl $3, %ecx
 520 ; CHECK-NEXT: callq f
 521 ; CHECK-NEXT: [[test3_after_f3:.+]]:
 522 ; CHECK: .seh_proc [[test3_fault1:[^ ]+]]
 523 ; CHECK: # %fault1
 524 ; CHECK: .seh_endprologue
 525 ; CHECK: [[test3_before_f2:.+]]:
 526 ; CHECK-NEXT: movl $2, %ecx
 527 ; CHECK-NEXT: callq f
 528 ; CHECK-NEXT: [[test3_after_f2:.+]]:
 529 ; CHECK: [[test3_end:.*func_end.*]]:
 530 }
 531
 532 ; Now check for EH table in xdata (following standard xdata)
 533 ; CHECK-LABEL: .section .xdata
 534 ; standard xdata comes here
 535 ; CHECK:      .long 7{{$}}
 536 ;                   ^ number of funclets
 537 ; CHECK-NEXT: .long [[test3_fault4]]-[[test3_begin]]
 538 ;                   ^ offset from L_begin to start of 1st funclet
 539 ; CHECK-NEXT: .long [[test3_catch1]]-[[test3_begin]]
 540 ;                   ^ offset from L_begin to start of 2nd funclet
 541 ; CHECK-NEXT: .long [[test3_catch2]]-[[test3_begin]]
 542 ;                   ^ offset from L_begin to start of 3rd funclet
 543 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 544 ;                   ^ offset from L_begin to start of 4th funclet
 545 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 546 ;                   ^ offset from L_begin to start of 5th funclet
 547 ; CHECK-NEXT: .long [[test3_fault2]]-[[test3_begin]]
 548 ;                   ^ offset from L_begin to start of 6th funclet
 549 ; CHECK-NEXT: .long [[test3_fault1]]-[[test3_begin]]
 550 ;                   ^ offset from L_begin to start of 7th funclet
 551 ; CHECK-NEXT: .long [[test3_end]]-[[test3_begin]]
 552 ;                   ^ offset from L_begin to end of last funclet
 553 ; CHECK-NEXT: .long 10
 554 ;                   ^ number of EH clauses
 555 ; Clause 1: call f(1) is guarded by fault1
 556 ; CHECK-NEXT: .long 4
 557 ;                   ^ flags (4 => fault handler)
 558 ; CHECK-NEXT: .long ([[test3_before_f1]]-[[test3_begin]])+1
 559 ;                   ^ offset of start of clause
 560 ; CHECK-NEXT: .long ([[test3_after_f1]]-[[test3_begin]])+1
 561 ;                   ^ offset of end of clause
 562 ; CHECK-NEXT: .long [[test3_fault1]]-[[test3_begin]]
 563 ;                   ^ offset of start of handler
 564 ; CHECK-NEXT: .long [[test3_end]]-[[test3_begin]]
 565 ;                   ^ offset of end of handler
 566 ; CHECK-NEXT: .long 0
 567 ;                   ^ type token slot (null for fault)
 568 ; Clause 3: call f(6) is guarded by catch1
 569 ; CHECK-NEXT: .long 0
 570 ;                   ^ flags (0 => catch handler)
 571 ; CHECK-NEXT: .long ([[test3_before_f6]]-[[test3_begin]])+1
 572 ;                   ^ offset of start of clause
 573 ; CHECK-NEXT: .long ([[test3_after_f6]]-[[test3_begin]])+1
 574 ;                   ^ offset of end of clause
 575 ; CHECK-NEXT: .long [[test3_catch1]]-[[test3_begin]]
 576 ;                   ^ offset of start of handler
 577 ; CHECK-NEXT: .long [[test3_catch2]]-[[test3_begin]]
 578 ;                   ^ offset of end of handler
 579 ; CHECK-NEXT: .long 1
 580 ;                   ^ type token of catch (from catchpad)
 581 ; Clause 3: call f(6) is also guarded by catch2
 582 ; CHECK-NEXT: .long 0
 583 ;                   ^ flags (0 => catch handler)
 584 ; CHECK-NEXT: .long ([[test3_before_f6]]-[[test3_begin]])+1
 585 ;                   ^ offset of start of clause
 586 ; CHECK-NEXT: .long ([[test3_after_f6]]-[[test3_begin]])+1
 587 ;                   ^ offset of end of clause
 588 ; CHECK-NEXT: .long [[test3_catch2]]-[[test3_begin]]
 589 ;                   ^ offset of start of handler
 590 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 591 ;                   ^ offset of end of handler
 592 ; CHECK-NEXT: .long 2
 593 ;                   ^ type token of catch (from catchpad)
 594 ; Clause 4: call f(7) is guarded by fault5
 595 ;           This is a "duplicate" because the protected range (f(6)-f(7))
 596 ;           is in funclet fault4 but fault5's immediate parent
 597 ;           is fault1, not that funclet.
 598 ; CHECK-NEXT: .long 12
 599 ;                   ^ flags (4 => fault handler | 8 => duplicate)
 600 ; CHECK-NEXT: .long ([[test3_before_f7]]-[[test3_begin]])+1
 601 ;                   ^ offset of start of clause
 602 ; CHECK-NEXT: .long ([[test3_after_f7]]-[[test3_begin]])+1
 603 ;                   ^ offset of end of clause
 604 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 605 ;                   ^ offset of start of handler
 606 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 607 ;                   ^ offset of end of handler
 608 ; CHECK-NEXT: .long 0
 609 ;                   ^ type token slot (null for fault)
 610 ; Clause 5: call f(4) is guarded by fault4
 611 ; CHECK-NEXT: .long 4
 612 ;                   ^ flags (4 => fault handler)
 613 ; CHECK-NEXT: .long ([[test3_before_f4]]-[[test3_begin]])+1
 614 ;                   ^ offset of start of clause
 615 ; CHECK-NEXT: .long ([[test3_after_f4]]-[[test3_begin]])+1
 616 ;                   ^ offset of end of clause
 617 ; CHECK-NEXT: .long [[test3_fault4]]-[[test3_begin]]
 618 ;                   ^ offset of start of handler
 619 ; CHECK-NEXT: .long [[test3_catch1]]-[[test3_begin]]
 620 ;                   ^ offset of end of handler
 621 ; CHECK-NEXT: .long 0
 622 ;                   ^ type token slot (null for fault)
 623 ; Clause 6: call f(4) is also guarded by fault5
 624 ;           This is a "duplicate" because the protected range (f(4))
 625 ;           is in funclet fault3 but fault5's immediate parent
 626 ;           is fault1, not that funclet.
 627 ; CHECK-NEXT: .long 12
 628 ;                   ^ flags (4 => fault handler)
 629 ; CHECK-NEXT: .long ([[test3_before_f4]]-[[test3_begin]])+1
 630 ;                   ^ offset of start of clause
 631 ; CHECK-NEXT: .long ([[test3_after_f4]]-[[test3_begin]])+1
 632 ;                   ^ offset of end of clause
 633 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 634 ;                   ^ offset of start of handler
 635 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 636 ;                   ^ offset of end of handler
 637 ; CHECK-NEXT: .long 0
 638 ;                   ^ type token slot (null for fault)
 639 ; Clause 7: call f(3) is guarded by fault3
 640 ; CHECK-NEXT: .long 4
 641 ;                   ^ flags (4 => fault handler)
 642 ; CHECK-NEXT: .long ([[test3_before_f3]]-[[test3_begin]])+1
 643 ;                   ^ offset of start of clause
 644 ; CHECK-NEXT: .long ([[test3_after_f3]]-[[test3_begin]])+1
 645 ;                   ^ offset of end of clause
 646 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 647 ;                   ^ offset of start of handler
 648 ; CHECK-NEXT: .long [[test3_fault2]]-[[test3_begin]]
 649 ;                   ^ offset of end of handler
 650 ; CHECK-NEXT: .long 0
 651 ;                   ^ type token slot (null for fault)
 652 ; Clause 8: call f(3) is guarded by fault5
 653 ;           This is a "duplicate" because the protected range (f(3))
 654 ;           is in funclet fault2 but fault5's immediate parent
 655 ;           is fault1, not that funclet.
 656 ; CHECK-NEXT: .long 12
 657 ;                   ^ flags (4 => fault handler | 8 => duplicate)
 658 ; CHECK-NEXT: .long ([[test3_before_f3]]-[[test3_begin]])+1
 659 ;                   ^ offset of start of clause
 660 ; CHECK-NEXT: .long ([[test3_after_f3]]-[[test3_begin]])+1
 661 ;                   ^ offset of end of clause
 662 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 663 ;                   ^ offset of start of handler
 664 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 665 ;                   ^ offset of end of handler
 666 ; CHECK-NEXT: .long 0
 667 ;                   ^ type token slot (null for fault)
 668 ; Clause 9: call f(2) is guarded by fault2
 669 ; CHECK-NEXT: .long 4
 670 ;                   ^ flags (4 => fault handler)
 671 ; CHECK-NEXT: .long ([[test3_before_f2]]-[[test3_begin]])+1
 672 ;                   ^ offset of start of clause
 673 ; CHECK-NEXT: .long ([[test3_after_f2]]-[[test3_begin]])+1
 674 ;                   ^ offset of end of clause
 675 ; CHECK-NEXT: .long [[test3_fault2]]-[[test3_begin]]
 676 ;                   ^ offset of start of handler
 677 ; CHECK-NEXT: .long [[test3_fault1]]-[[test3_begin]]
 678 ;                   ^ offset of end of handler
 679 ; CHECK-NEXT: .long 0
 680 ;                   ^ type token slot (null for fault)
 681 ; Clause 10: call f(2) is guarded by fault5
 682 ; CHECK-NEXT: .long 4
 683 ;                   ^ flags (4 => fault handler)
 684 ; CHECK-NEXT: .long ([[test3_before_f2]]-[[test3_begin]])+1
 685 ;                   ^ offset of start of clause
 686 ; CHECK-NEXT: .long ([[test3_after_f2]]-[[test3_begin]])+1
 687 ;                   ^ offset of end of clause
 688 ; CHECK-NEXT: .long [[test3_fault5]]-[[test3_begin]]
 689 ;                   ^ offset of start of handler
 690 ; CHECK-NEXT: .long [[test3_fault3]]-[[test3_begin]]
 691 ;                   ^ offset of end of handler
 692 ; CHECK-NEXT: .long 0
 693 ;                   ^ type token slot (null for fault)