[WebAssembly] Fix fixEndsAtEndOfFunction for delegate

[aheejin]

Summary

Background:
CFGStackify's fixEndsAtEndOfFunction fixes block/loop/try's return
type when the end of function is unreachable and the function return
type is not void. So if a function returns i32 and block-end wraps the
whole function, i.e., the block's end is the last instruction of the
function, the block's return type should be i32 too:

block i32
  ...
end
end_function

If there are consecutive ends, this signature has to be propagate to
those blocks too, like:

block i32
  ...
  block i32
    ...
  end
end
end_function

This applies to try-end too:

try i32
  ...
catch
  ...
end
end_function

In case of try, we not only follow consecutive ends but also follow
catch, because for the type of the whole try to be i32, both try
and catch parts have to be i32:

try i32
  ...
  block i32
    ...
  end
catch
  ...
  block i32
    ...
  end
end
end_function

---

Previously we only handled consecutive ends or end before a catch.
But now we have delegate, which serves like end for
try-delegate. So we have to follow delegate too and mark its
corresponding try as i32 (the function's return type):

try i32
  ...
catch
  ...
  try i32    ;; Here
    ...
  delegate N
end
end_function

llvm/lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

while (It != MBB->rend()) {
         auto NextIt =
             std::next(WebAssembly::findCatch(EHPad)->getReverseIterator());
         if (NextIt != EHPad->rend())
           Worklist.push_back(NextIt);
         LLVM_FALLTHROUGH;
       }
       case WebAssembly::END_BLOCK:
       case WebAssembly::END_LOOP:
+      case WebAssembly::DELEGATE:
         EndToBegin[&MI]->getOperand(0).setImm(int32_t(RetType));
         continue;
       default:
         // Something other than an `end`. We're done for this BB.
         return;
       }
     }
     // We've reached the beginning of a BB. Continue the search in the previous

llvm/test/CodeGen/WebAssembly/cfg-stackify-eh.mir

 # RUN: llc -mtriple=wasm32-unknown-unknown -exception-model=wasm -mattr=+exception-handling -run-pass wasm-cfg-stackify %s -o - | FileCheck %s
 
 --- |
   target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   target triple = "wasm32-unknown-unknown"
 
   declare i32 @__gxx_wasm_personality_v0(...)
   declare void @foo()
   define void @rethrow_arg_test() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
     ret void
   }
+  define i32 @fix_end_function_test() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+    ret i32 0
+  }
 ...
 
 ---
 # CHECK-LABEL: name: rethrow_arg_test
 name: rethrow_arg_test
 liveins:
   - { reg: '$arguments' }
 body: |
bb.1 (landing-pad):
     EH_LABEL <mcsymbol .Ltmp2>
     %0:i32 = CATCH &__cpp_exception, implicit-def dead $arguments
     RETHROW 0, implicit-def dead $arguments
 
   bb.2 (landing-pad):
     ; CHECK: bb.2 (landing-pad):
     ; CHECK: CATCH
     ; CHECK: RETHROW 0
-    EH_LABEL <mcsymbol .Ltmp5>
+    EH_LABEL <mcsymbol .Ltmp3>
     %1:i32 = CATCH &__cpp_exception, implicit-def dead $arguments
     RETHROW 0, implicit-def dead $arguments
 
   bb.3:
     ; CHECK: bb.3:
     ; CHECK: END_TRY
     ; CHECK: END_TRY
     RETURN implicit-def dead $arguments
 ...
+
+---
+# This function has i32 return type and the end of the function is unreachable,
+# so CFGStackify's fixEndsAtEndOfFunction() propagates the return type while
+# they encounter 'end' or 'delegate'. This is a regression test for a bug that
+# we only handled 'end' but not 'delegate'.
+# CHECK-LABEL: name: fix_end_function_test
+name: fix_end_function_test
+liveins:
+  - { reg: '$arguments' }
+machineFunctionInfo:
+  params:          [  ]
+  results:         [ i32 ]
+  wasmEHFuncInfo:
+    3:               4
+body: |
+  ; CHECK: TRY 127
+  ; CHECK:   TRY 127
+  ; CHECK:     CALL @foo
+  ; CHECK:     TRY 64
+  ; CHECK:       CALL @foo
+  ; CHECK:     DELEGATE
+  ; CHECK:     RETURN
+  ; CHECK:   CATCH
+  ;; This TRY should have the return type i32 (127)
+  ; CHECK:     TRY 127
+  ; CHECK:       RETHROW
+  ; CHECK:     DELEGATE
+  ; CHECK:   END_TRY
+  ; CHECK: CATCH
+  ; CHECK:   RETHROW
+  ; CHECK: END_TRY
+  bb.0:
+    successors: %bb.1, %bb.3
+    EH_LABEL <mcsymbol .Ltmp0>
+    CALL @foo, implicit-def dead $arguments, implicit $sp32, implicit $sp64
+    EH_LABEL <mcsymbol .Ltmp1>
+
+  bb.1:
+    successors: %bb.2, %bb.4
+    EH_LABEL <mcsymbol .Ltmp2>
+    CALL @foo, implicit-def dead $arguments, implicit $sp32, implicit $sp64
+    EH_LABEL <mcsymbol .Ltmp3>
+
+  bb.2:
+    %0:i32 = CONST_I32 3, implicit-def dead $arguments
+    RETURN %0:i32, implicit-def dead $arguments
+
+  bb.3 (landing-pad):
+    EH_LABEL <mcsymbol .Ltmp4>
+    %0:i32 = CATCH &__cpp_exception, implicit-def dead $arguments
+    RETHROW 0, implicit-def dead $arguments
+
+  bb.4 (landing-pad):
+    EH_LABEL <mcsymbol .Ltmp5>
+    %1:i32 = CATCH &__cpp_exception, implicit-def dead $arguments
+    RETHROW 0, implicit-def dead $arguments
+...