[SROA] Bail out on PHIs in catchswitch BBs

[aheejin]

Summary

In the process of rewriting allocas and phis that use them, the SROA
pass can try to insert a non-PHI instruction by calling
getFirstInsertionPt(), which is not possible in a catchswitch BB. This
CL makes we bail out on these cases.

[lebedev.ri]

llvm/test/Transforms/SROA/phi-catchswitch.ll

2

There is no run line in this test, so it doesn't actually test anything.

[aheejin]

Add RUN line + checks

[aheejin]

llvm/test/Transforms/SROA/phi-catchswitch.ll

2

Oh right.. Added it, thanks.

[aheejin]

Add CHECK-LABEL

[aheejin]

Add preds comments to test

[dschuff]

Thanks for fixing this.

llvm/lib/Transforms/Scalar/SROA.cpp

Instruction *hasUnsafePHIOrSelectUse(Instruction *Root, uint64_t &Size) {
     return nullptr;
   }
 
   void visitPHINodeOrSelectInst(Instruction &I) {
     assert(isa<PHINode>(I) || isa<SelectInst>(I));
     if (I.use_empty())
       return markAsDead(I);
 
+    // If this is a PHI node before a catchswitch, we cannot insert any non-PHI
+    // instructions in this BB, which may be required during rewriting. Bail out
+    // on these cases.
+    if (isa<PHINode>(I) &&
+        I.getParent()->getFirstInsertionPt() == I.getParent()->end())
+      return PI.setAborted(&I);
+
     // TODO: We could use SimplifyInstruction here to fold PHINodes and
     // SelectInsts. However, doing so requires to change the current
     // dead-operand-tracking mechanism. For instance, suppose neither loading
     // from %U nor %other traps. Then "load (select undef, %U, %other)" does not
     // trap either.  However, if we simply replace %U with undef using the
     // current dead-operand-tracking mechanism, "load (select undef, undef,
     // %other)" may trap because the select may return the first operand
     // "undef".

llvm/test/Transforms/SROA/phi-catchswitch.ll

+; RUN: opt < %s -sroa -S | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+%struct.foo = type { i32 }
+declare i32 @__gxx_wasm_personality_v0(...)
+declare void @foo()
+
+; Tests if the SROA pass correctly bails out on rewriting PHIs in a catchswitch
+; BB.
+; CHECK-LABEL: @test_phi_catchswitch
+define void @test_phi_catchswitch() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+entry:
+  ; CHECK: alloca
+  %tmp = alloca %struct.foo, align 4
+  %tmp2 = getelementptr inbounds %struct.foo, %struct.foo* %tmp, i32 0, i32 0
+  invoke void @foo()
+          to label %bb3 unwind label %bb10
+
+bb3:                                              ; preds = %entry
+  invoke void @foo()
+          to label %bb9 unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %bb3
+  ; While rewriting the alloca in the entry BB, the SROA pass tries to insert a
+  ; non-PHI instruction in this BB by calling getFirstInsertionPt(), which is
+  ; not possible in a catchswitch BB. This test checks if we correctly bail out
+  ; on these cases.
+  %tmp5 = phi i32* [ %tmp2, %bb3 ]
+  %tmp6 = catchswitch within none [label %catch.start] unwind label %bb10
+
+catch.start:                                      ; preds = %catch.dispatch
+  %tmp8 = catchpad within %tmp6 [i8* null]
+  unreachable
+
+bb9:                                              ; preds = %bb3
+  unreachable
+
+bb10:                                             ; preds = %catch.dispatch, %entry
+  %tmp11 = phi i32* [ %tmp2, %entry ], [ %tmp5, %catch.dispatch ]
+  %tmp12 = cleanuppad within none []
+  store i32 0, i32* %tmp11, align 4
+  unreachable
+}