[Verifier] Check catchpad for MSVC_CXX Personality

[pengfei]

Summary

An alternative to D143739.

[rnk]

lgtm, thanks!

This will, for example, prevent a pass like ASan from moving the catch object into the dynamic stack allocation. And, it looks like we have that exact bug:
https://gcc.godbolt.org/z/3aveP3rbj

See the IR, which uses a catch object based on the dynamic alloca:

  store i64 %11, ptr %asan_local_stack_base, align 8
  %12 = add i64 %11, 32
  %13 = inttoptr i64 %12 to ptr
...
catch:                                            ; preds = %catch.dispatch
  %24 = catchpad within %23 [ptr @"??_R0H@8", i32 0, ptr %13], !dbg !19

So, this will break builds using ASan and WinEH, but they are already known to be incompatible. +@akhuang

llvm/lib/IR/Verifier.cpp

 
 void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
   BasicBlock *BB = CPI.getParent();
 
   Function *F = BB->getParent();
   Check(F->hasPersonalityFn(),
         "CatchPadInst needs to be in a function with a personality.", &CPI);
 
+  // Only MSVC CXX catchpad handles alloca.
+  if (classifyEHPersonality(F->getPersonalityFn()) == EHPersonality::MSVC_CXX) {
+    Check(CPI.getNumOperands() == 4, "WinEH catchpad needs 4 operands.", &CPI);
+    Value *V = CPI.getArgOperand(2)->stripPointerCasts();
+    if (auto *AI = dyn_cast<AllocaInst>(V))
+      Check(AI->isStaticAlloca(), "WinEH needs static alloca", &CPI);
+    else
+      Check(isa<ConstantPointerNull>(V),
+            "Catch object needs to be alloca or null ptr", &CPI);
+  }
+
   Check(isa<CatchSwitchInst>(CPI.getParentPad()),
         "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
         CPI.getParentPad());
 
   // The catchpad instruction must be the first non-PHI instruction in the
   // block.
   Check(BB->getFirstNonPHI() == &CPI,
         "CatchPadInst not the first non-PHI instruction in the block.", &CPI);

llvm/test/CodeGen/WinEH/wineh-cloning.ll

 entry:
   ; %x def colors: {entry} subset of use colors; must spill
   %x = call i32 @llvm.qux()
   invoke void @f()
     to label %noreturn unwind label %catch.switch
 catch.switch:
   %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  %cp = catchpad within %cs []
+  %cp = catchpad within %cs [ptr null, i32 0, ptr null]
   br label %noreturn
 noreturn:
   ; %x use colors: {entry, cleanup}
   call void @llvm.foo(i32 %x)
   unreachable
 }
 ; Need two copies of the call to @h, one under entry and one under catch.
 ; Currently we generate a load for each, though we shouldn't need one
 ; for the use in entry's copy.
 ; CHECK-LABEL: define void @test1(
 ; CHECK: entry:
 ; CHECK:   %x = call i32 @llvm.qux()
 ; CHECK:   invoke void @f()
 ; CHECK:     to label %[[EntryCopy:[^ ]+]] unwind label %catch
 ; CHECK: catch.switch:
 ; CHECK:   %cs = catchswitch within none [label %catch] unwind to caller
 ; CHECK: catch:
-; CHECK:   catchpad within %cs []
+; CHECK:   catchpad within %cs [ptr null, i32 0, ptr null]
 ; CHECK-NEXT: call void @llvm.foo(i32 %x)
 ; CHECK: [[EntryCopy]]:
 ; CHECK:   call void @llvm.foo(i32 %x)
 
 
 define void @test2() personality ptr @__CxxFrameHandler3 {
 entry:
   invoke void @f()
entry:
   invoke void @f()
     to label %invoke.cont unwind label %catch.switch
 invoke.cont:
   invoke void @f()
     to label %exit unwind label %cleanup
 catch.switch:
   %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchpad within %cs []
+  catchpad within %cs [ptr null, i32 0, ptr null]
   br label %shared
 cleanup:
   cleanuppad within none []
   br label %shared
 shared:
   call void @llvm.bar()
   br label %exit
 exit:
   ret void
 }
 ; Need two copies of %shared's call to @f (similar to @test2 but
 ; the two regions here are siblings, not parent-child).
 ; CHECK-LABEL: define void @test3(
 ; CHECK:   invoke void @f()
 ; CHECK:   invoke void @f()
 ; CHECK:     to label %[[exit:[^ ]+]] unwind
 ; CHECK: catch:
-; CHECK:   catchpad within %cs []
+; CHECK:   catchpad within %cs [ptr null, i32 0, ptr null]
 ; CHECK-NEXT: call void @llvm.bar()
 ; CHECK-NEXT: unreachable
 ; CHECK: cleanup:
 ; CHECK:   cleanuppad within none []
 ; CHECK:   call void @llvm.bar()
 ; CHECK-NEXT: unreachable
 ; CHECK: [[exit]]:
 ; CHECK:   ret void
 
 
 define void @test4() personality ptr @__CxxFrameHandler3 {
 entry:
   invoke void @f()
     to label %shared unwind label %catch.switch
 catch.switch:
   %cs = catchswitch within none [label %catch] unwind to caller
 catch:
-  catchpad within %cs []
+  catchpad within %cs [ptr null, i32 0, ptr null]
   br label %shared
 shared:
   %x = call i32 @llvm.qux()
   %i = call i32 @llvm.qux()
   %zero.trip = icmp eq i32 %i, 0
   br i1 %zero.trip, label %exit, label %loop
 loop:
   %i.loop = phi i32 [ %i, %shared ], [ %i.dec, %loop.tail ]

 }
 ; Make sure we can clone regions that have internal control
 ; flow and SSA values.  Here we need two copies of everything
 ; from %shared to %exit.
 ; CHECK-LABEL: define void @test4(
 ; CHECK:  entry:
 ; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch.switch
 ; CHECK:  catch:
-; CHECK:    catchpad within %cs []
+; CHECK:    catchpad within %cs [ptr null, i32 0, ptr null]
 ; CHECK:    [[x_C:%[^ ]+]] = call i32 @llvm.qux()
 ; CHECK:    [[i_C:%[^ ]+]] = call i32 @llvm.qux()
 ; CHECK:    [[zt_C:%[^ ]+]] = icmp eq i32 [[i_C]], 0
 ; CHECK:    br i1 [[zt_C]], label %[[exit_C:[^ ]+]], label %[[loop_C:[^ ]+]]
 ; CHECK:  [[shared_E]]:
 ; CHECK:    [[x_E:%[^ ]+]] = call i32 @llvm.qux()
 ; CHECK:    [[i_E:%[^ ]+]] = call i32 @llvm.qux()
 ; CHECK:    [[zt_E:%[^ ]+]] = icmp eq i32 [[i_E]], 0
inner:
   %cleanup = cleanuppad within none []
   ; make sure we don't overlook this cleanupret and try to process
   ; successor %outer as a child of inner.
   cleanupret from %cleanup unwind label %outer
 outer:
   %cs = catchswitch within none [label %catch.body] unwind to caller
 
 catch.body:
-  %catch = catchpad within %cs []
+  %catch = catchpad within %cs [ptr null, i32 0, ptr null]
   catchret from %catch to label %exit
 exit:
   ret void
 unreachable:
   unreachable
 }
 ; CHECK-LABEL: define void @test10(
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   invoke
 ; CHECK-NEXT:     to label %unreachable unwind label %inner
 ; CHECK:      inner:
 ; CHECK-NEXT:   %cleanup = cleanuppad within none []
 ; CHECK-NEXT:   cleanupret from %cleanup unwind label %outer
 ; CHECK:      outer:
 ; CHECK-NEXT:   %cs = catchswitch within none [label %catch.body] unwind to caller
 ; CHECK:      catch.body:
-; CHECK-NEXT:   %catch = catchpad within %cs []
+; CHECK-NEXT:   %catch = catchpad within %cs [ptr null, i32 0, ptr null]
 ; CHECK-NEXT:   catchret from %catch to label %exit
 ; CHECK:      exit:
 ; CHECK-NEXT:   ret void
 
 define void @test11() personality ptr @__C_specific_handler {
 entry:
   invoke void @f()
     to label %exit unwind label %cleanup.outer

llvm/test/CodeGen/WinEH/wineh-demotion.ll

invoke void @f()
           to label %exit unwind label %merge
 merge:
   ; CHECK: merge:
   ; CHECK-NOT: = phi
   %phi = phi i32 [ %x, %left ], [ %y, %right ]
   %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
-  %cp = catchpad within %cs1 []
+  %cp = catchpad within %cs1 [ptr null, i32 0, ptr null]
   ; CHECK: catch:
   ; CHECK: [[Reload:%[^ ]+]] = load i32, ptr [[Slot]]
   ; CHECK-NEXT: call void @h(i32 [[Reload]])
   call void @h(i32 %phi) [ "funclet"(token %cp) ]
   catchret from %cp to label %exit
 
 exit:
   ret void

 merge.inner:
   ; CHECK: merge.inner:
   ; CHECK-NOT: = phi
   ; CHECK: catchswitch within none
   %x = phi i32 [ 1, %left ], [ 2, %right ]
   %cs1 = catchswitch within none [label %catch.inner] unwind label %merge.outer
 
 catch.inner:
-  %cpinner = catchpad within %cs1 []
+  %cpinner = catchpad within %cs1 [ptr null, i32 0, ptr null]
   ; Need just one store here because only %y is affected
   ; CHECK: catch.inner:
   %z = call i32 @g() [ "funclet"(token %cpinner) ]
   ; CHECK:   store i32 %z
   ; CHECK-NEXT: invoke void @f
   invoke void @f() [ "funclet"(token %cpinner) ]
           to label %catchret.inner unwind label %merge.outer
 
 catchret.inner:
   catchret from %cpinner to label %exit
 
 merge.outer:
   %y = phi i32 [ %x, %merge.inner ], [ %z, %catch.inner ]
   ; CHECK: merge.outer:
   ; CHECK-NOT: = phi
   ; CHECK: catchswitch within none
   %cs2 = catchswitch within none [label %catch.outer] unwind to caller
 
 catch.outer:
-  %cpouter = catchpad within %cs2 []
+  %cpouter = catchpad within %cs2 [ptr null, i32 0, ptr null]
   ; CHECK: catch.outer:
-  ; CHECK: [[CatchPad:%[^ ]+]] = catchpad within %cs2 []
+  ; CHECK: [[CatchPad:%[^ ]+]] = catchpad within %cs2 [ptr null, i32 0, ptr null]
   ; Need to load x and y from two different slots since they're both live
   ; and can have different values (if we came from catch.inner)
   ; CHECK-DAG: load i32, ptr [[Slot1]]
   ; CHECK-DAG: load i32, ptr [[Slot2]]
   ; CHECK: catchret from [[CatchPad]] to label
   call void @h(i32 %x) [ "funclet"(token %cpouter) ]
   call void @h(i32 %y) [ "funclet"(token %cpouter) ]
   catchret from %cpouter to label %exit
right:
   invoke void @f()
           to label %join unwind label %catchpad.inner
 catchpad.inner:
    ; CHECK: catchpad.inner:
    ; CHECK-NEXT: catchswitch within none
    %phi.inner = phi i32 [ %l, %left ], [ %r, %right ]
    %cs1 = catchswitch within none [label %catch.inner] unwind label %catchpad.outer
 catch.inner:
-   %cp1 = catchpad within %cs1 []
+   %cp1 = catchpad within %cs1 [ptr null, i32 0, ptr null]
    catchret from %cp1 to label %join
 join:
   ; CHECK: join:
   ; CHECK-NOT: store
   ; CHECK: store i32 %j, ptr [[Slot]]
   ; CHECK-NEXT: invoke void @f
    %j = call i32 @g()
    invoke void @f()
            to label %exit unwind label %catchpad.outer
 
 catchpad.outer:
    ; CHECK: catchpad.outer:
    ; CHECK-NEXT: catchswitch within none
    %phi.outer = phi i32 [ %phi.inner, %catchpad.inner ], [ %j, %join ]
    %cs2 = catchswitch within none [label %catch.outer] unwind to caller
 catch.outer:
    ; CHECK: catch.outer:
    ; CHECK:   [[Reload:%[^ ]+]] = load i32, ptr [[Slot]]
    ; CHECK:   call void @h(i32 [[Reload]])
-   %cp2 = catchpad within %cs2 []
+   %cp2 = catchpad within %cs2 [ptr null, i32 0, ptr null]
    call void @h(i32 %phi.outer) [ "funclet"(token %cp2) ]
    catchret from %cp2 to label %exit
 exit:
    ret void
 }
 
 ; CHECK-LABEL: @test5(
 define void @test5() personality ptr @__CxxFrameHandler3 {
catchswitch:
   %phi.catch = phi i32 [ %phi.cleanup, %merge ], [ 3, %invoke.cont2 ]
   %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
   ; CHECK: catch:
   ; CHECK:   catchpad within %cs1
   ; CHECK:   [[CatchReload:%[^ ]+]] = load i32, ptr [[CatchSlot]]
   ; CHECK:   call void @h(i32 [[CatchReload]]
-  %cp2 = catchpad within %cs1 []
+  %cp2 = catchpad within %cs1 [ptr null, i32 0, ptr null]
   call void @h(i32 %phi.catch) [ "funclet"(token %cp2) ]
   catchret from %cp2 to label %exit
 
 exit:
   ret void
 }
 
 ; We used to demote %x, but we don't need to anymore.

 catchpad:
   ; %x phi should be eliminated
   ; CHECK: catchpad:
   ; CHECK-NEXT: catchswitch within none
   %x = phi i32 [ 1, %entry ], [ 2, %invoke.cont ]
   %cs1 = catchswitch within none [label %catch] unwind to caller
 catch:
   ; CHECK: catch:
-  ; CHECK-NEXT: %[[CatchPad:[^ ]+]] = catchpad within %cs1 []
-  %cp = catchpad within %cs1 []
+  ; CHECK-NEXT: %[[CatchPad:[^ ]+]] = catchpad within %cs1 [ptr null, i32 0, ptr null]
+  %cp = catchpad within %cs1 [ptr null, i32 0, ptr null]
   %b = call i1 @i() [ "funclet"(token %cp) ]
   br i1 %b, label %left, label %right
 left:
   ; Edge from %left to %join needs to be split so that
   ; the load of %x can be inserted *after* the catchret
   ; CHECK: left:
   ; CHECK-NEXT: catchret from %[[CatchPad]] to label %[[SplitLeft:[^ ]+]]
   catchret from %cp to label %join

llvm/test/CodeGen/WinEH/wineh-intrinsics.ll

 
 define void @test1() personality ptr @__CxxFrameHandler3 {
 entry:
   invoke void (...) @f(i32 1)
      to label %exit unwind label %catchpad
 catchpad:
   %cs1 = catchswitch within none [label %do_catch] unwind to caller
 do_catch:
-  %catch = catchpad within %cs1 [i32 1]
+  %catch = catchpad within %cs1 [ptr null, i32 0, ptr null]
   %exn = call ptr @llvm.eh.exceptionpointer.p0(token %catch)
   call void (...) @f(ptr %exn)
   catchret from %catch to label %exit
 exit:
   ret void
 }
 
 define void @test2() personality ptr @ProcessManagedException {

llvm/test/Transforms/CodeGenPrepare/X86/catchpad-phi-cast.ll

 
 done:
   ret void
 
 catch1:
   %cs1 = catchswitch within none [label %handler1] unwind to caller
 
 handler1:
-  %cp1 = catchpad within %cs1 []
+  %cp1 = catchpad within %cs1 [ptr null, i32 0, ptr null]
   br label %catch.shared
 ; CHECK: handler1:
 ; CHECK-NEXT: catchpad within %cs1
 
 catch2:
   %cs2 = catchswitch within none [label %handler2] unwind to caller
 
 handler2:
-  %cp2 = catchpad within %cs2 []
+  %cp2 = catchpad within %cs2 [ptr null, i32 0, ptr null]
   br label %catch.shared
 ; CHECK: handler2:
 ; CHECK: catchpad within %cs2
 
 ; CHECK: catch.shared:
 ; CHECK-NEXT: %p = phi ptr [ %x, %handler1 ], [ %y, %handler2 ]
 catch.shared:
   %p = phi ptr [ %x, %handler1 ], [ %y, %handler2 ]

 ret:
   ret void
 
 catch.dispatch:
   %p = phi ptr [%a, %entry], [%b, %next]
   %cs1 = catchswitch within none [label %catch] unwind to caller
 
 catch:
-  %cp1 = catchpad within %cs1 []
+  %cp1 = catchpad within %cs1 [ptr null, i32 0, ptr null]
   tail call void @llvm.dbg.value(metadata ptr %p, i64 0, metadata !11, metadata !13), !dbg !14
   call void @g(ptr %p)
   catchret from %cp1 to label %ret
 
 ; CHECK: catch.dispatch:
 ; CHECK-NEXT: phi ptr
 ; CHECK-NEXT: catchswitch
 ; CHECK-NOT: llvm.dbg.value

llvm/test/Transforms/DeadStoreElimination/multiblock-exceptions.ll

 ; CHECK-NEXT:    store i32 20, ptr [[SV]]
 ; CHECK-NEXT:    invoke void @f()
 ; CHECK-NEXT:    to label [[BLOCK3:%.*]] unwind label [[CATCH_DISPATCH:%.*]]
 ; CHECK:       block3:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       catch.dispatch:
 ; CHECK-NEXT:    [[CS1:%.*]] = catchswitch within none [label %catch] unwind label [[CLEANUP:%.*]]
 ; CHECK:       catch:
-; CHECK-NEXT:    [[C:%.*]] = catchpad within [[CS1]] []
+; CHECK-NEXT:    [[C:%.*]] = catchpad within [[CS1]] [ptr null, i32 0, ptr null]
 ; CHECK-NEXT:    [[LV:%.*]] = load i32, ptr [[SV]]
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       cleanup:
 ; CHECK-NEXT:    [[C1:%.*]] = cleanuppad within none []
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;

 block3:
   store i32 30, ptr %sv
   br label %exit
 
 catch.dispatch:
   %cs1 = catchswitch within none [label %catch] unwind label %cleanup
 
 catch:
-  %c = catchpad within %cs1 []
+  %c = catchpad within %cs1 [ptr null, i32 0, ptr null]
   %lv = load i32, ptr %sv
   br label %exit
 
 cleanup:
   %c1 = cleanuppad within none []
   br label %exit
 
 exit:
   store i32 40, ptr %sv
   ret void
 }

llvm/test/Transforms/GVN/PRE/pre-load.ll

 ; CHECK:       block2:
 ; CHECK-NEXT:    invoke void @f()
 ; CHECK-NEXT:    to label [[BLOCK3:%.*]] unwind label [[CLEANUP:%.*]]
 ; CHECK:       block3:
 ; CHECK-NEXT:    ret void
 ; CHECK:       catch.dispatch:
 ; CHECK-NEXT:    [[CS1:%.*]] = catchswitch within none [label %catch] unwind label [[CLEANUP2:%.*]]
 ; CHECK:       catch:
-; CHECK-NEXT:    [[C:%.*]] = catchpad within [[CS1]] []
+; CHECK-NEXT:    [[C:%.*]] = catchpad within [[CS1]] [ptr null, i32 0, ptr null]
 ; CHECK-NEXT:    catchret from [[C]] to label [[BLOCK2]]
 ; CHECK:       cleanup:
 ; CHECK-NEXT:    [[C1:%.*]] = cleanuppad within none []
 ; CHECK-NEXT:    store i32 0, ptr [[P:%.*]], align 4
 ; CHECK-NEXT:    cleanupret from [[C1]] unwind label [[CLEANUP2]]
 ; CHECK:       cleanup2:
 ; CHECK-NEXT:    [[C2:%.*]] = cleanuppad within none []
 ; CHECK-NEXT:    [[NOTPRE:%.*]] = load i32, ptr [[P]], align 4

 
 block3:
   ret void
 
 catch.dispatch:
   %cs1 = catchswitch within none [label %catch] unwind label %cleanup2
 
 catch:
-  %c = catchpad within %cs1 []
+  %c = catchpad within %cs1 [ptr null, i32 0, ptr null]
   catchret from %c to label %block2
 
 cleanup:
   %c1 = cleanuppad within none []
   store i32 0, ptr %p
   cleanupret from %c1 unwind label %cleanup2
 
 cleanup2:

llvm/test/Transforms/GlobalOpt/preallocated.ll

 ; CHECK-NEXT:    [[A:%.*]] = call ptr @llvm.call.preallocated.arg(token [[C]], i32 0) #[[ATTR1]]
 ; CHECK-NEXT:    [[R:%.*]] = invoke i32 @preallocated_invoke(ptr preallocated(i32) [[A]]) [ "preallocated"(token [[C]]) ]
 ; CHECK-NEXT:    to label [[CONTA:%.*]] unwind label [[CONTB:%.*]]
 ; CHECK:       conta:
 ; CHECK-NEXT:    ret i32 [[R]]
 ; CHECK:       contb:
 ; CHECK-NEXT:    [[S:%.*]] = catchswitch within none [label %catch] unwind to caller
 ; CHECK:       catch:
-; CHECK-NEXT:    [[P:%.*]] = catchpad within [[S]] []
+; CHECK-NEXT:    [[P:%.*]] = catchpad within [[S]] [ptr null, i32 0, ptr null]
 ; CHECK-NEXT:    catchret from [[P]] to label [[CONT:%.*]]
 ; CHECK:       cont:
 ; CHECK-NEXT:    ret i32 42
 ;
   %c = call token @llvm.call.preallocated.setup(i32 1)
   %a = call ptr @llvm.call.preallocated.arg(token %c, i32 0) preallocated(i32)
   %r = invoke i32 @preallocated_invoke(ptr preallocated(i32) %a) ["preallocated"(token %c)]
   to label %conta unwind label %contb
 conta:
   ret i32 %r
 contb:
   %s = catchswitch within none [label %catch] unwind to caller
 catch:
-  %p = catchpad within %s []
+  %p = catchpad within %s [ptr null, i32 0, ptr null]
   catchret from %p to label %cont
 cont:
   ret i32 42
 }

llvm/test/Transforms/InstCombine/token.ll

invoke void @g(i32 0)
     to label %unreachable
     unwind label %catch
 
 catch:
   %phi = phi i32 [ %X, %bb ], [ %Y, %cont ]
   %cs = catchswitch within none [label %doit] unwind to caller
 
 doit:
-  %cl = catchpad within %cs []
+  %cl = catchpad within %cs [ptr null, i32 0, ptr null]
   call void @g(i32 %phi)
   unreachable
 
 unreachable:
   unreachable
 }
 
 ; CHECK-LABEL: define void @test2(
invoke void @g(i32 0)
     to label %unreachable
     unwind label %catch
 
 catch:
   %phi = phi i32 [ %X, %bb ], [ %Y, %cont ], [ %Y, %cont2 ]
   %cs = catchswitch within none [label %doit] unwind to caller
 
 doit:
-  %cl = catchpad within %cs []
+  %cl = catchpad within %cs [ptr null, i32 0, ptr null]
   call void @g(i32 %phi)
   unreachable
 
 unreachable:
   unreachable
 }
 
 ; CHECK-LABEL: define void @test3(

llvm/test/Transforms/SimpleLoopUnswitch/nontrivial-unswitch.ll

 
 loop_latch:
   br label %loop_begin
 
 loop_catch:
   %catch = catchswitch within none [label %loop_catch_latch, label %loop_exit] unwind to caller
 
 loop_catch_latch:
-  %catchpad_latch = catchpad within %catch []
+  %catchpad_latch = catchpad within %catch [ptr null, i32 0, ptr null]
   catchret from %catchpad_latch to label %loop_begin
 
 loop_exit:
-  %catchpad_exit = catchpad within %catch []
+  %catchpad_exit = catchpad within %catch [ptr null, i32 0, ptr null]
   catchret from %catchpad_exit to label %exit
 
 exit:
   ret void
 }
 
 
 ; Non-trivial loop unswitching where there are two distinct trivial conditions

llvm/test/Verifier/preallocated-valid.ll

define void @preallocated_teardown_invoke() personality ptr @__CxxFrameHandler3 {
     %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
     invoke void @constructor(ptr %x) to label %conta unwind label %contb
 conta:
     call void @foo1(ptr preallocated(i32) %x) ["preallocated"(token %cs)]
     ret void
 contb:
     %s = catchswitch within none [label %catch] unwind to caller
 catch:
-    %p = catchpad within %s []
+    %p = catchpad within %s [ptr null, i32 0, ptr null]
     call void @llvm.call.preallocated.teardown(token %cs)
     ret void
 }