[Outlining] Insert Unreachable (#7400)

When the last instruction of the outlined sequence is unreachable, we
need to insert an unreachable instruction immediately after the call to
the outlined function. This maintains the unreachable type in the
original scope of the outlined sequence.

Author: ashleynh

src/passes/Outlining.cpp

@@ -219,12 +219,27 @@ struct ReconstructStringifyWalker
     // call will replace the instructions moved to the outlined function.
     ASSERT_OK(existingBuilder.makeCall(outlinedFunc->name, false));
     DBG(std::cerr << "\ncreated outlined fn: " << outlinedFunc->name << "\n");
+
+    // If the last instruction of the outlined sequence is unreachable, insert
+    // an unreachable instruction immediately after the call to the outlined
+    // function. This maintains the unreachable type in the original scope
+    // of the outlined sequence.
+    if (sequences[seqCounter].endsTypeUnreachable) {
+      ASSERT_OK(existingBuilder.makeUnreachable());
+    }
   }
 
   void transitionToInSkipSeq() {
     Function* outlinedFunc =
       getModule()->getFunction(sequences[seqCounter].func);
     ASSERT_OK(existingBuilder.makeCall(outlinedFunc->name, false));
+    // If the last instruction of the outlined sequence is unreachable, insert
+    // an unreachable instruction immediately after the call to the outlined
+    // function. This maintains the unreachable type in the original scope
+    // of the outlined sequence.
+    if (sequences[seqCounter].endsTypeUnreachable) {
+      ASSERT_OK(existingBuilder.makeUnreachable());
+    }
     DBG(std::cerr << "\nstarting to skip instructions "
                   << sequences[seqCounter].startIdx << " - "
                   << sequences[seqCounter].endIdx - 1 << " to "
@@ -351,8 +366,12 @@ struct Outlining : public Pass {
         // sequence relative to its function is better for outlining because we
         // walk functions.
         auto [relativeIdx, existingFunc] = stringify.makeRelative(seqIdx);
-        auto seq =
-          OutliningSequence(relativeIdx, relativeIdx + substring.Length, func);
+        auto seq = OutliningSequence(
+          relativeIdx,
+          relativeIdx + substring.Length,
+          func,
+          stringify.exprs[seqIdx + substring.Length - 1]->type ==
+            Type::unreachable);
         seqByFunc[existingFunc].push_back(seq);
       }
     }

src/passes/stringify-walker.h

@@ -254,9 +254,14 @@ struct OutliningSequence {
   unsigned startIdx;
   unsigned endIdx;
   Name func;
-
-  OutliningSequence(unsigned startIdx, unsigned endIdx, Name func)
-    : startIdx(startIdx), endIdx(endIdx), func(func) {}
+  bool endsTypeUnreachable;
+
+  OutliningSequence(unsigned startIdx,
+                    unsigned endIdx,
+                    Name func,
+                    bool endsTypeUnreachable)
+    : startIdx(startIdx), endIdx(endIdx), func(func),
+      endsTypeUnreachable(endsTypeUnreachable) {}
 };
 
 using Substrings = std::vector<SuffixTree::RepeatedSubstring>;

test/lit/passes/outlining.wast

@@ -1074,3 +1074,38 @@
     drop        ;; End substring 2 repeat
   )
 )
+
+;; Tests unreachable type handling
+(module
+  ;; CHECK:      (type $0 (func))
+
+  ;; CHECK:      (type $1 (func (result f32)))
+
+  ;; CHECK:      (type $2 (func (result i32)))
+
+  ;; CHECK:      (func $outline$ (type $0)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $a (type $1) (result f32)
+  ;; CHECK-NEXT:  (call $outline$)
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $a (result f32)
+    i32.const 0
+    drop
+    unreachable
+  )
+  ;; CHECK:      (func $b (type $2) (result i32)
+  ;; CHECK-NEXT:  (call $outline$)
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $b (result i32)
+    i32.const 0
+    drop
+    unreachable
+  )
+)