Monomorphize dropped functions (#6734)

We now consider a drop to be part of the call context: If we see

(drop
  (call $foo)
)

(func $foo (result i32)
  (i32.const 42)
)

Then we'd monomorphize to this:

(call $foo_1)  ;; call the specialized function instead

(func $foo_1   ;; the specialized function returns nothing
  (drop        ;; the drop was moved into here
    (i32.const 42)
  )
)

With the drop now in the called function, we may be able to optimize out unused work.

Refactor a bit of code out of DAE that we can reuse here, into a new return-utils.h.

6 files changed, 1418 insertions, 36 deletions

diff --git a/src/ir/CMakeLists.txt b/src/ir/CMakeLists.txt
index 996daa564..45b08702d 100644
--- a/src/ir/CMakeLists.txt
+++ b/src/ir/CMakeLists.txt
@@ -17,6 +17,7 @@ set(ir_SOURCES
   LocalGraph.cpp
   LocalStructuralDominance.cpp
   ReFinalize.cpp
+  return-utils.cpp
   stack-utils.cpp
   table-utils.cpp
   type-updating.cpp
diff --git a/src/ir/return-utils.cpp b/src/ir/return-utils.cpp
new file mode 100644
index 000000000..20b3a194b
--- /dev/null
+++ b/src/ir/return-utils.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2024 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ir/return-utils.h"
+#include "ir/module-utils.h"
+#include "wasm-builder.h"
+#include "wasm-traversal.h"
+#include "wasm.h"
+
+namespace wasm::ReturnUtils {
+
+namespace {
+
+struct ReturnValueRemover : public PostWalker<ReturnValueRemover> {
+  void visitReturn(Return* curr) {
+    auto* value = curr->value;
+    assert(value);
+    curr->value = nullptr;
+    Builder builder(*getModule());
+    replaceCurrent(builder.makeSequence(builder.makeDrop(value), curr));
+  }
+
+  void visitCall(Call* curr) { handleReturnCall(curr); }
+  void visitCallIndirect(CallIndirect* curr) { handleReturnCall(curr); }
+  void visitCallRef(CallRef* curr) { handleReturnCall(curr); }
+
+  template<typename T> void handleReturnCall(T* curr) {
+    if (curr->isReturn) {
+      Fatal() << "Cannot remove return_calls in ReturnValueRemover";
+    }
+  }
+
+  void visitFunction(Function* curr) {
+    if (curr->body->type.isConcrete()) {
+      curr->body = Builder(*getModule()).makeDrop(curr->body);
+    }
+  }
+};
+
+} // anonymous namespace
+
+void removeReturns(Function* func, Module& wasm) {
+  ReturnValueRemover().walkFunctionInModule(func, &wasm);
+}
+
+std::unordered_map<Function*, bool> findReturnCallers(Module& wasm) {
+  ModuleUtils::ParallelFunctionAnalysis<bool> analysis(
+    wasm, [&](Function* func, bool& hasReturnCall) {
+      if (func->imported()) {
+        return;
+      }
+
+      struct Finder : PostWalker<Finder> {
+        bool hasReturnCall = false;
+
+        void visitCall(Call* curr) {
+          if (curr->isReturn) {
+            hasReturnCall = true;
+          }
+        }
+        void visitCallIndirect(CallIndirect* curr) {
+          if (curr->isReturn) {
+            hasReturnCall = true;
+          }
+        }
+        void visitCallRef(CallRef* curr) {
+          if (curr->isReturn) {
+            hasReturnCall = true;
+          }
+        }
+      } finder;
+
+      finder.walk(func->body);
+      hasReturnCall = finder.hasReturnCall;
+    });
+
+  // Convert to an unordered map for fast lookups. TODO: Avoid a copy here.
+  std::unordered_map<Function*, bool> ret;
+  ret.reserve(analysis.map.size());
+  for (auto& [k, v] : analysis.map) {
+    ret[k] = v;
+  }
+  return ret;
+}
+
+} // namespace wasm::ReturnUtils
diff --git a/src/ir/return-utils.h b/src/ir/return-utils.h
new file mode 100644
index 000000000..a5214ba01
--- /dev/null
+++ b/src/ir/return-utils.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_ir_return_h
+#define wasm_ir_return_h
+
+#include "wasm.h"
+
+namespace wasm::ReturnUtils {
+
+// Removes values from both explicit returns and implicit ones (values that flow
+// from the body). This is useful after changing a function's type to no longer
+// return anything.
+//
+// This does *not* handle return calls, and will error on them. Removing a
+// return call may change the semantics of the program, so we do not do it
+// automatically here.
+void removeReturns(Function* func, Module& wasm);
+
+// Return a map of every function to whether it does a return call.
+using ReturnCallersMap = std::unordered_map<Function*, bool>;
+ReturnCallersMap findReturnCallers(Module& wasm);
+
+} // namespace wasm::ReturnUtils
+
+#endif // wasm_ir_return_h
diff --git a/src/passes/DeadArgumentElimination.cpp b/src/passes/DeadArgumentElimination.cpp
index 4a341571e..83cd7e86d 100644
--- a/src/passes/DeadArgumentElimination.cpp
+++ b/src/passes/DeadArgumentElimination.cpp
@@ -42,6 +42,7 @@
 #include "ir/find_all.h"
 #include "ir/lubs.h"
 #include "ir/module-utils.h"
+#include "ir/return-utils.h"
 #include "ir/type-updating.h"
 #include "ir/utils.h"
 #include "param-utils.h"
@@ -358,23 +359,7 @@ private:
       }
     }
     // Remove any return values.
-    struct ReturnUpdater : public PostWalker<ReturnUpdater> {
-      Module* module;
-      ReturnUpdater(Function* func, Module* module) : module(module) {
-        walk(func->body);
-      }
-      void visitReturn(Return* curr) {
-        auto* value = curr->value;
-        assert(value);
-        curr->value = nullptr;
-        Builder builder(*module);
-        replaceCurrent(builder.makeSequence(builder.makeDrop(value), curr));
-      }
-    } returnUpdater(func, module);
-    // Remove any value flowing out.
-    if (func->body->type.isConcrete()) {
-      func->body = Builder(*module).makeDrop(func->body);
-    }
+    ReturnUtils::removeReturns(func, *module);
   }
 
   // Given a function and all the calls to it, see if we can refine the type of
diff --git a/src/passes/Monomorphize.cpp b/src/passes/Monomorphize.cpp
index c27f5d6eb..8c08db55b 100644
--- a/src/passes/Monomorphize.cpp
+++ b/src/passes/Monomorphize.cpp
@@ -92,6 +92,7 @@
 #include "ir/manipulation.h"
 #include "ir/module-utils.h"
 #include "ir/names.h"
+#include "ir/return-utils.h"
 #include "ir/type-updating.h"
 #include "ir/utils.h"
 #include "pass.h"
@@ -103,6 +104,36 @@ namespace wasm {
 
 namespace {
 
+// Core information about a call: the call itself, and if it is dropped, the
+// drop.
+struct CallInfo {
+  Call* call;
+  // Store a reference to the drop's pointer so that we can replace it, as when
+  // we optimize a dropped call we need to replace (drop (call)) with (call).
+  // Or, if the call is not dropped, this is nullptr.
+  Expression** drop;
+};
+
+// Finds the calls and whether each one of them is dropped.
+struct CallFinder : public PostWalker<CallFinder> {
+  std::vector<CallInfo> infos;
+
+  void visitCall(Call* curr) {
+    // Add the call as not having a drop, and update the drop later if we are.
+    infos.push_back(CallInfo{curr, nullptr});
+  }
+
+  void visitDrop(Drop* curr) {
+    if (curr->value->is<Call>()) {
+      // The call we just added to |infos| is dropped.
+      assert(!infos.empty());
+      auto& back = infos.back();
+      assert(back.call == curr->value);
+      back.drop = getCurrentPointer();
+    }
+  }
+};
+
 // Relevant information about a callsite for purposes of monomorphization.
 struct CallContext {
   // The operands of the call, processed to leave the parts that make sense to
@@ -181,12 +212,12 @@ struct CallContext {
   // remaining values by updating |newOperands| (for example, if all the values
   // sent are constants, then |newOperands| will end up empty, as we have
   // nothing left to send).
-  void buildFromCall(Call* call,
+  void buildFromCall(CallInfo& info,
                      std::vector<Expression*>& newOperands,
                      Module& wasm) {
     Builder builder(wasm);
 
-    for (auto* operand : call->operands) {
+    for (auto* operand : info.call->operands) {
       // Process the operand. This is a copy operation, as we are trying to move
       // (copy) code from the callsite into the called function. When we find we
       // can copy then we do so, and when we cannot that value remains as a
@@ -212,8 +243,7 @@ struct CallContext {
         }));
     }
 
-    // TODO: handle drop
-    dropped = false;
+    dropped = !!info.drop;
   }
 
   // Checks whether an expression can be moved into the context.
@@ -299,6 +329,11 @@ struct Monomorphize : public Pass {
   void run(Module* module) override {
     // TODO: parallelize, see comments below
 
+    // Find all the return-calling functions. We cannot remove their returns
+    // (because turning a return call into a normal call may break the program
+    // by using more stack).
+    auto returnCallersMap = ReturnUtils::findReturnCallers(*module);
+
     // Note the list of all functions. We'll be adding more, and do not want to
     // operate on those.
     std::vector<Name> funcNames;
@@ -309,26 +344,38 @@ struct Monomorphize : public Pass {
     // to call the monomorphized targets.
     for (auto name : funcNames) {
       auto* func = module->getFunction(name);
-      for (auto* call : FindAll<Call>(func->body).list) {
-        if (call->type == Type::unreachable) {
+
+      CallFinder callFinder;
+      callFinder.walk(func->body);
+      for (auto& info : callFinder.infos) {
+        if (info.call->type == Type::unreachable) {
           // Ignore unreachable code.
           // TODO: return_call?
           continue;
         }
 
-        if (call->target == name) {
+        if (info.call->target == name) {
           // Avoid recursion, which adds some complexity (as we'd be modifying
           // ourselves if we apply optimizations).
           continue;
         }
 
-        processCall(call, *module);
+        // If the target function does a return call, then as noted earlier we
+        // cannot remove its returns, so do not consider the drop as part of the
+        // context in such cases (as if we reverse-inlined the drop into the
+        // target then we'd be removing the returns).
+        if (returnCallersMap[module->getFunction(info.call->target)]) {
+          info.drop = nullptr;
+        }
+
+        processCall(info, *module);
       }
     }
   }
 
   // Try to optimize a call.
-  void processCall(Call* call, Module& wasm) {
+  void processCall(CallInfo& info, Module& wasm) {
+    auto* call = info.call;
     auto target = call->target;
     auto* func = wasm.getFunction(target);
     if (func->imported()) {
@@ -342,7 +389,7 @@ struct Monomorphize : public Pass {
     // if we use that context.
     CallContext context;
     std::vector<Expression*> newOperands;
-    context.buildFromCall(call, newOperands, wasm);
+    context.buildFromCall(info, newOperands, wasm);
 
     // See if we've already evaluated this function + call context. If so, then
     // we've memoized the result.
@@ -350,11 +397,8 @@ struct Monomorphize : public Pass {
     if (iter != funcContextMap.end()) {
       auto newTarget = iter->second;
       if (newTarget != target) {
-        // When we computed this before we found a benefit to optimizing, and
-        // created a new monomorphized function to call. Use it by simply
-        // applying the new operands we computed, and adjusting the call target.
-        call->operands.set(newOperands);
-        call->target = newTarget;
+        // We saw benefit to optimizing this case. Apply that.
+        updateCall(info, newTarget, newOperands, wasm);
       }
       return;
     }
@@ -419,8 +463,7 @@ struct Monomorphize : public Pass {
     if (worthwhile) {
       // We are using the monomorphized function, so update the call and add it
       // to the module.
-      call->operands.set(newOperands);
-      call->target = monoFunc->name;
+      updateCall(info, monoFunc->name, newOperands, wasm);
 
       wasm.addFunction(std::move(monoFunc));
     }
@@ -453,8 +496,9 @@ struct Monomorphize : public Pass {
         newParams.push_back(operand->type);
       }
     }
-    // TODO: support changes to results.
-    auto newResults = func->getResults();
+    // If we were dropped then we are pulling the drop into the monomorphized
+    // function, which means we return nothing.
+    auto newResults = context.dropped ? Type::none : func->getResults();
     newFunc->type = Signature(Type(newParams), newResults);
 
     // We must update local indexes: the new function has a  potentially
@@ -549,9 +593,32 @@ struct Monomorphize : public Pass {
       newFunc->body = builder.makeBlock(pre);
     }
 
+    if (context.dropped) {
+      ReturnUtils::removeReturns(newFunc.get(), wasm);
+    }
+
     return newFunc;
   }
 
+  // Given a call and a new target it should be calling, apply that new target,
+  // including updating the operands and handling dropping.
+  void updateCall(const CallInfo& info,
+                  Name newTarget,
+                  const std::vector<Expression*>& newOperands,
+                  Module& wasm) {
+    info.call->target = newTarget;
+    info.call->operands.set(newOperands);
+
+    if (info.drop) {
+      // Replace (drop (call)) with (call), that is, replace the drop with the
+      // (updated) call which now has type none. Note we should have handled
+      // unreachability before getting here.
+      assert(info.call->type != Type::unreachable);
+      info.call->type = Type::none;
+      *info.drop = info.call;
+    }
+  }
+
   // Run some function-level optimizations on a function. Ideally we would run a
   // minimal amount of optimizations here, but we do want to give the optimizer
   // as much of a chance to work as possible, so for now do all of -O3 (in
diff --git a/test/lit/passes/monomorphize-drop.wast b/test/lit/passes/monomorphize-drop.wast
new file mode 100644
index 000000000..63923f768
--- /dev/null
+++ b/test/lit/passes/monomorphize-drop.wast
@@ -0,0 +1,1191 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; As in monomorphize-types.wast, test in both "always" mode, which always
+;; monomorphizes, and in "careful" mode which does it only when it appears to
+;; actually help.
+
+;; RUN: foreach %s %t wasm-opt --monomorphize-always -all -S -o - | filecheck %s --check-prefix ALWAYS
+;; RUN: foreach %s %t wasm-opt --monomorphize        -all -S -o - | filecheck %s --check-prefix CAREFUL
+
+(module
+  ;; Test that dropped functions are monomorphized, and the drop is reverse-
+  ;; inlined into the called function, enabling more optimizations.
+
+  ;; ALWAYS:      (type $0 (func (result i32)))
+
+  ;; ALWAYS:      (type $1 (func (param i32)))
+
+  ;; ALWAYS:      (type $2 (func (param i32 i32) (result i32)))
+
+  ;; ALWAYS:      (type $3 (func (param i32) (result i32)))
+
+  ;; ALWAYS:      (type $4 (func))
+
+  ;; ALWAYS:      (type $5 (func (param i32 i32)))
+
+  ;; ALWAYS:      (func $work (type $2) (param $x i32) (param $y i32) (result i32)
+  ;; ALWAYS-NEXT:  (i32.mul
+  ;; ALWAYS-NEXT:   (i32.xor
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:    (local.get $y)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:   (i32.div_s
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:    (local.get $y)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (type $0 (func (result i32)))
+
+  ;; CAREFUL:      (type $1 (func (param i32)))
+
+  ;; CAREFUL:      (type $2 (func (param i32 i32) (result i32)))
+
+  ;; CAREFUL:      (type $3 (func (param i32) (result i32)))
+
+  ;; CAREFUL:      (type $4 (func))
+
+  ;; CAREFUL:      (type $5 (func (param i32 i32)))
+
+  ;; CAREFUL:      (func $work (type $2) (param $0 i32) (param $1 i32) (result i32)
+  ;; CAREFUL-NEXT:  (i32.mul
+  ;; CAREFUL-NEXT:   (i32.div_s
+  ;; CAREFUL-NEXT:    (local.get $0)
+  ;; CAREFUL-NEXT:    (local.get $1)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:   (i32.xor
+  ;; CAREFUL-NEXT:    (local.get $0)
+  ;; CAREFUL-NEXT:    (local.get $1)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $work (param $x i32) (param $y i32) (result i32)
+    ;; Do some nontrivial work that we return. If this is dropped then we don't
+    ;; need that work.
+    (i32.mul
+      (i32.xor
+        (local.get $x)
+        (local.get $y)
+      )
+      (i32.div_s
+        (local.get $x)
+        (local.get $y)
+      )
+    )
+  )
+
+  ;; ALWAYS:      (func $calls (type $1) (param $x i32)
+  ;; ALWAYS-NEXT:  (call $work_5)
+  ;; ALWAYS-NEXT:  (call $work_5)
+  ;; ALWAYS-NEXT:  (call $work_6
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (call $work_7
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $calls (type $1) (param $x i32)
+  ;; CAREFUL-NEXT:  (call $work_5)
+  ;; CAREFUL-NEXT:  (call $work_5)
+  ;; CAREFUL-NEXT:  (call $work_6
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (call $work_7
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $calls (param $x i32)
+    ;; Both of these can call the same monomorphized function. In CAREFUL mode
+    ;; that function's body can also be optimized into a nop.
+    (drop
+      (call $work
+        (i32.const 3)
+        (i32.const 4)
+      )
+    )
+    (drop
+      (call $work
+        (i32.const 3)
+        (i32.const 4)
+      )
+    )
+    ;; Another call, now with an unknown parameter. This calls a different
+    ;; monomorphized function, but once again the body can be optimized into a
+    ;; nop in CAREFUL.
+    (drop
+      (call $work
+        (i32.const 3)
+        (local.get $x)
+      )
+    )
+    ;; Two unknown parameters. Yet another monomorphized function, but the same
+    ;; outcome.
+    (drop
+      (call $work
+        (local.get $x)
+        (local.get $x)
+      )
+    )
+  )
+
+  ;; ALWAYS:      (func $call-undropped-trivial (type $3) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (call $work
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-undropped-trivial (type $3) (param $x i32) (result i32)
+  ;; CAREFUL-NEXT:  (call $work
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-undropped-trivial (param $x i32) (result i32)
+    ;; A call of the same target that is dropped in the previous function, but
+    ;; now without a drop. We know nothing nontrivial here, so we do nothing.
+    (call $work
+      (local.get $x)
+      (local.get $x)
+    )
+  )
+
+  ;; ALWAYS:      (func $call-undropped (type $0) (result i32)
+  ;; ALWAYS-NEXT:  (call $work_8)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-undropped (type $0) (result i32)
+  ;; CAREFUL-NEXT:  (call $work_8)
+  ;; CAREFUL-NEXT: )
+  (func $call-undropped (result i32)
+    ;; As above but now with constant params. We can monomorphize here - there
+    ;; is no issue in optimizing here without a drop and with a drop elsewhere -
+    ;; but we do call a different function of course, that returns an i32.
+    (call $work
+      (i32.const 3)
+      (i32.const 4)
+    )
+  )
+
+  ;; ALWAYS:      (func $call-no-params-return (type $0) (result i32)
+  ;; ALWAYS-NEXT:  (return_call $work
+  ;; ALWAYS-NEXT:   (i32.const 10)
+  ;; ALWAYS-NEXT:   (i32.const 20)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-no-params-return (type $0) (result i32)
+  ;; CAREFUL-NEXT:  (return_call $work
+  ;; CAREFUL-NEXT:   (i32.const 10)
+  ;; CAREFUL-NEXT:   (i32.const 20)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-no-params-return (result i32)
+    ;; Return calls can be monomorphized too, but we have that as a TODO atm.
+    (return_call $work
+      (i32.const 10)
+      (i32.const 20)
+    )
+  )
+)
+
+;; ALWAYS:      (func $work_5 (type $4)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local $y i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (i32.const 3)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (local.set $y
+;; ALWAYS-NEXT:     (i32.const 4)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (i32.mul
+;; ALWAYS-NEXT:     (i32.xor
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.div_s
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $work_6 (type $1) (param $0 i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local $y i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (i32.const 3)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (local.set $y
+;; ALWAYS-NEXT:     (local.get $0)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (i32.mul
+;; ALWAYS-NEXT:     (i32.xor
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.div_s
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $work_7 (type $5) (param $0 i32) (param $1 i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local $y i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (local.get $0)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (local.set $y
+;; ALWAYS-NEXT:     (local.get $1)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (i32.mul
+;; ALWAYS-NEXT:     (i32.xor
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.div_s
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $work_8 (type $0) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local $y i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 3)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (local.set $y
+;; ALWAYS-NEXT:   (i32.const 4)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (i32.mul
+;; ALWAYS-NEXT:   (i32.xor
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (local.get $y)
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.div_s
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (local.get $y)
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $work_5 (type $4)
+;; CAREFUL-NEXT:  (nop)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $work_6 (type $1) (param $0 i32)
+;; CAREFUL-NEXT:  (drop
+;; CAREFUL-NEXT:   (i32.div_s
+;; CAREFUL-NEXT:    (i32.const 3)
+;; CAREFUL-NEXT:    (local.get $0)
+;; CAREFUL-NEXT:   )
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $work_7 (type $5) (param $0 i32) (param $1 i32)
+;; CAREFUL-NEXT:  (drop
+;; CAREFUL-NEXT:   (i32.div_s
+;; CAREFUL-NEXT:    (local.get $0)
+;; CAREFUL-NEXT:    (local.get $1)
+;; CAREFUL-NEXT:   )
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $work_8 (type $0) (result i32)
+;; CAREFUL-NEXT:  (i32.const 0)
+;; CAREFUL-NEXT: )
+(module
+  ;; ALWAYS:      (type $0 (func))
+
+  ;; ALWAYS:      (type $1 (func (param i32 i32) (result i32)))
+
+  ;; ALWAYS:      (type $2 (func (result i32)))
+
+  ;; ALWAYS:      (import "a" "b" (func $import (type $1) (param i32 i32) (result i32)))
+  ;; CAREFUL:      (type $0 (func))
+
+  ;; CAREFUL:      (type $1 (func (param i32 i32) (result i32)))
+
+  ;; CAREFUL:      (type $2 (func (result i32)))
+
+  ;; CAREFUL:      (import "a" "b" (func $import (type $1) (param i32 i32) (result i32)))
+  (import "a" "b" (func $import (param i32 i32) (result i32)))
+
+  ;; ALWAYS:      (func $no-params (type $2) (result i32)
+  ;; ALWAYS-NEXT:  (i32.const 42)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $no-params (type $2) (result i32)
+  ;; CAREFUL-NEXT:  (i32.const 42)
+  ;; CAREFUL-NEXT: )
+  (func $no-params (result i32)
+    ;; A function that will be dropped, and has no params.
+    (i32.const 42)
+  )
+
+  ;; ALWAYS:      (func $call-no-params (type $2) (result i32)
+  ;; ALWAYS-NEXT:  (call $no-params_6)
+  ;; ALWAYS-NEXT:  (call $no-params)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-no-params (type $2) (result i32)
+  ;; CAREFUL-NEXT:  (call $no-params_6)
+  ;; CAREFUL-NEXT:  (call $no-params)
+  ;; CAREFUL-NEXT: )
+  (func $call-no-params (result i32)
+    ;; We can optimize the drop into the target.
+    (drop
+      (call $no-params)
+    )
+    ;; Without a drop, the call context is trivial and we do nothing.
+    (call $no-params)
+  )
+
+  ;; ALWAYS:      (func $call-import (type $0)
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $import
+  ;; ALWAYS-NEXT:    (i32.const 3)
+  ;; ALWAYS-NEXT:    (i32.const 4)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-import (type $0)
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $import
+  ;; CAREFUL-NEXT:    (i32.const 3)
+  ;; CAREFUL-NEXT:    (i32.const 4)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-import
+    ;; Calling an import allows no optimizations.
+    (drop
+      (call $import
+        (i32.const 3)
+        (i32.const 4)
+      )
+    )
+  )
+
+  ;; ALWAYS:      (func $import-work (type $1) (param $x i32) (param $y i32) (result i32)
+  ;; ALWAYS-NEXT:  (call $import
+  ;; ALWAYS-NEXT:   (i32.xor
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:    (local.get $y)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:   (i32.div_s
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:    (local.get $y)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $import-work (type $1) (param $0 i32) (param $1 i32) (result i32)
+  ;; CAREFUL-NEXT:  (call $import
+  ;; CAREFUL-NEXT:   (i32.xor
+  ;; CAREFUL-NEXT:    (local.get $0)
+  ;; CAREFUL-NEXT:    (local.get $1)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:   (i32.div_s
+  ;; CAREFUL-NEXT:    (local.get $0)
+  ;; CAREFUL-NEXT:    (local.get $1)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $import-work (param $x i32) (param $y i32) (result i32)
+    ;; Do some work and also call an import.
+    (call $import
+      (i32.xor
+        (local.get $x)
+        (local.get $y)
+      )
+      (i32.div_s
+        (local.get $x)
+        (local.get $y)
+      )
+    )
+  )
+
+  ;; ALWAYS:      (func $call-import-work (type $0)
+  ;; ALWAYS-NEXT:  (call $import-work_7)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-import-work (type $0)
+  ;; CAREFUL-NEXT:  (call $import-work_7)
+  ;; CAREFUL-NEXT: )
+  (func $call-import-work
+    ;; This is monomorphized with the drop.
+    (drop
+      (call $import-work
+        (i32.const 3)
+        (i32.const 4)
+      )
+    )
+  )
+)
+
+;; ALWAYS:      (func $no-params_6 (type $0)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (i32.const 42)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $import-work_7 (type $0)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local $y i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (i32.const 3)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (local.set $y
+;; ALWAYS-NEXT:     (i32.const 4)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (call $import
+;; ALWAYS-NEXT:     (i32.xor
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.div_s
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (local.get $y)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $no-params_6 (type $0)
+;; CAREFUL-NEXT:  (nop)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $import-work_7 (type $0)
+;; CAREFUL-NEXT:  (drop
+;; CAREFUL-NEXT:   (call $import
+;; CAREFUL-NEXT:    (i32.const 7)
+;; CAREFUL-NEXT:    (i32.const 0)
+;; CAREFUL-NEXT:   )
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+(module
+  ;; ALWAYS:      (type $0 (func (param i32)))
+
+  ;; ALWAYS:      (type $1 (func))
+
+  ;; ALWAYS:      (type $2 (func (result i32)))
+
+  ;; ALWAYS:      (type $3 (func (param i32) (result i32)))
+
+  ;; ALWAYS:      (import "a" "c" (func $import (type $2) (result i32)))
+  ;; CAREFUL:      (type $0 (func (param i32)))
+
+  ;; CAREFUL:      (type $1 (func))
+
+  ;; CAREFUL:      (type $2 (func (result i32)))
+
+  ;; CAREFUL:      (type $3 (func (param i32) (result i32)))
+
+  ;; CAREFUL:      (import "a" "c" (func $import (type $2) (result i32)))
+  (import "a" "c" (func $import (result i32)))
+
+  ;; ALWAYS:      (func $return-normal (type $3) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (drop
+  ;; ALWAYS-NEXT:     (call $import)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:    (return
+  ;; ALWAYS-NEXT:     (i32.const 0)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (i32.const 1)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $return-normal (type $3) (param $0 i32) (result i32)
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $0)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (drop
+  ;; CAREFUL-NEXT:     (call $import)
+  ;; CAREFUL-NEXT:    )
+  ;; CAREFUL-NEXT:    (return
+  ;; CAREFUL-NEXT:     (i32.const 0)
+  ;; CAREFUL-NEXT:    )
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (i32.const 1)
+  ;; CAREFUL-NEXT: )
+  (func $return-normal (param $x i32) (result i32)
+    ;; This function has a return, which needs to be handled in the
+    ;; monomorphized function, as we'll no longer return a value.
+    (if
+      (local.get $x)
+      (then
+        (drop
+          (call $import)
+        )
+        (return
+          (i32.const 0)
+        )
+      )
+    )
+    ;; Also return a value by flowing it out.
+    (i32.const 1)
+  )
+
+  ;; ALWAYS:      (func $call-return-normal (type $0) (param $x i32)
+  ;; ALWAYS-NEXT:  (call $return-normal_3)
+  ;; ALWAYS-NEXT:  (call $return-normal_4)
+  ;; ALWAYS-NEXT:  (call $return-normal_5
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-return-normal (type $0) (param $x i32)
+  ;; CAREFUL-NEXT:  (call $return-normal_3)
+  ;; CAREFUL-NEXT:  (call $return-normal_4)
+  ;; CAREFUL-NEXT:  (call $return-normal_5
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-return-normal (param $x i32)
+    ;; Call the above function with 0, 1, and an unknown value, to test the two
+    ;; code paths there + the case of the input being unknown. We monomorphize
+    ;; them all (differently).
+    (drop
+      (call $return-normal
+        (i32.const 0)
+      )
+    )
+    (drop
+      (call $return-normal
+        (i32.const 1)
+      )
+    )
+    (drop
+      (call $return-normal
+        (local.get $x)
+      )
+    )
+  )
+)
+
+;; ALWAYS:      (func $return-normal_3 (type $1)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (i32.const 0)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (block (result i32)
+;; ALWAYS-NEXT:     (if
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (then
+;; ALWAYS-NEXT:       (drop
+;; ALWAYS-NEXT:        (call $import)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:       (block
+;; ALWAYS-NEXT:        (drop
+;; ALWAYS-NEXT:         (i32.const 0)
+;; ALWAYS-NEXT:        )
+;; ALWAYS-NEXT:        (return)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:      )
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.const 1)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $return-normal_4 (type $1)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (i32.const 1)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (block (result i32)
+;; ALWAYS-NEXT:     (if
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (then
+;; ALWAYS-NEXT:       (drop
+;; ALWAYS-NEXT:        (call $import)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:       (block
+;; ALWAYS-NEXT:        (drop
+;; ALWAYS-NEXT:         (i32.const 0)
+;; ALWAYS-NEXT:        )
+;; ALWAYS-NEXT:        (return)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:      )
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.const 1)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $return-normal_5 (type $0) (param $0 i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (drop
+;; ALWAYS-NEXT:   (block (result i32)
+;; ALWAYS-NEXT:    (local.set $x
+;; ALWAYS-NEXT:     (local.get $0)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:    (block (result i32)
+;; ALWAYS-NEXT:     (if
+;; ALWAYS-NEXT:      (local.get $x)
+;; ALWAYS-NEXT:      (then
+;; ALWAYS-NEXT:       (drop
+;; ALWAYS-NEXT:        (call $import)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:       (block
+;; ALWAYS-NEXT:        (drop
+;; ALWAYS-NEXT:         (i32.const 0)
+;; ALWAYS-NEXT:        )
+;; ALWAYS-NEXT:        (return)
+;; ALWAYS-NEXT:       )
+;; ALWAYS-NEXT:      )
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:     (i32.const 1)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $return-normal_3 (type $1)
+;; CAREFUL-NEXT:  (nop)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $return-normal_4 (type $1)
+;; CAREFUL-NEXT:  (drop
+;; CAREFUL-NEXT:   (block
+;; CAREFUL-NEXT:    (drop
+;; CAREFUL-NEXT:     (call $import)
+;; CAREFUL-NEXT:    )
+;; CAREFUL-NEXT:    (return)
+;; CAREFUL-NEXT:   )
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $return-normal_5 (type $0) (param $0 i32)
+;; CAREFUL-NEXT:  (if
+;; CAREFUL-NEXT:   (local.get $0)
+;; CAREFUL-NEXT:   (then
+;; CAREFUL-NEXT:    (drop
+;; CAREFUL-NEXT:     (call $import)
+;; CAREFUL-NEXT:    )
+;; CAREFUL-NEXT:   )
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+(module
+  ;; ALWAYS:      (type $0 (func (result i32)))
+
+  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))
+
+  ;; ALWAYS:      (type $2 (func (param i32)))
+
+  ;; ALWAYS:      (import "a" "c" (func $import (type $0) (result i32)))
+  ;; CAREFUL:      (type $0 (func (result i32)))
+
+  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))
+
+  ;; CAREFUL:      (type $2 (func (param i32)))
+
+  ;; CAREFUL:      (import "a" "c" (func $import (type $0) (result i32)))
+  (import "a" "c" (func $import (result i32)))
+
+  ;; ALWAYS:      (func $return-call (type $1) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call $import)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (i32.const 1)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $return-call (type $1) (param $0 i32) (result i32)
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $0)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call $import)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (i32.const 1)
+  ;; CAREFUL-NEXT: )
+  (func $return-call (param $x i32) (result i32)
+    ;; As above, but now with a return_call. We do not monomorphize the drop
+    ;; part, as if we included the drop we'd turn the call into a non-return
+    ;; call, which can break things.
+    (if
+      (local.get $x)
+      (then
+        (return_call $import)
+      )
+    )
+    (i32.const 1)
+  )
+
+  ;; ALWAYS:      (func $call-return-call (type $2) (param $x i32)
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call_3)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call_4)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-return-call (type $2) (param $x i32)
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call_3)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call_4)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call
+  ;; CAREFUL-NEXT:    (local.get $x)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-return-call (param $x i32)
+    ;; As above, but due to the return call we won't monomorphize the drop. As
+    ;; a result we monomorphize the first two, leaving drops here, and do
+    ;; nothing for the last (as the call context is trivial).
+    (drop
+      (call $return-call
+        (i32.const 0)
+      )
+    )
+    (drop
+      (call $return-call
+        (i32.const 1)
+      )
+    )
+    (drop
+      (call $return-call
+        (local.get $x)
+      )
+    )
+  )
+)
+
+;; ALWAYS:      (func $return-call_3 (type $0) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 0)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call $import)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $return-call_4 (type $0) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call $import)
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $return-call_3 (type $0) (result i32)
+;; CAREFUL-NEXT:  (i32.const 1)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $return-call_4 (type $0) (result i32)
+;; CAREFUL-NEXT:  (return_call $import)
+;; CAREFUL-NEXT: )
+(module
+  ;; ALWAYS:      (type $i (func (result i32)))
+  ;; CAREFUL:      (type $i (func (result i32)))
+  (type $i (func (result i32)))
+
+  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))
+
+  ;; ALWAYS:      (type $2 (func (param i32)))
+
+  ;; ALWAYS:      (import "a" "c" (func $import (type $i) (result i32)))
+  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))
+
+  ;; CAREFUL:      (type $2 (func (param i32)))
+
+  ;; CAREFUL:      (import "a" "c" (func $import (type $i) (result i32)))
+  (import "a" "c" (func $import (result i32)))
+
+  ;; ALWAYS:      (table $table 10 10 funcref)
+  ;; CAREFUL:      (table $table 10 10 funcref)
+  (table $table 10 10 funcref)
+
+  ;; ALWAYS:      (func $return-call-indirect (type $1) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call_indirect $table (type $i)
+  ;; ALWAYS-NEXT:     (call $import)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (i32.const 1)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $return-call-indirect (type $1) (param $0 i32) (result i32)
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $0)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call_indirect $table (type $i)
+  ;; CAREFUL-NEXT:     (call $import)
+  ;; CAREFUL-NEXT:    )
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (i32.const 1)
+  ;; CAREFUL-NEXT: )
+  (func $return-call-indirect (param $x i32) (result i32)
+    ;; As above, but now with a return_call_indirect. The outcome below is
+    ;; similar.
+    (if
+      (local.get $x)
+      (then
+        (return_call_indirect (type $i)
+          (call $import)
+        )
+      )
+    )
+    (i32.const 1)
+  )
+
+  ;; ALWAYS:      (func $call-return-call-indirect (type $2) (param $x i32)
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-indirect_3)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-indirect_4)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-indirect
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-return-call-indirect (type $2) (param $x i32)
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-indirect_3)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-indirect_4)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-indirect
+  ;; CAREFUL-NEXT:    (local.get $x)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT: )
+  (func $call-return-call-indirect (param $x i32)
+    (drop
+      (call $return-call-indirect
+        (i32.const 0)
+      )
+    )
+    (drop
+      (call $return-call-indirect
+        (i32.const 1)
+      )
+    )
+    (drop
+      (call $return-call-indirect
+        (local.get $x)
+      )
+    )
+  )
+)
+
+;; ALWAYS:      (func $return-call-indirect_3 (type $i) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 0)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call_indirect $table (type $i)
+;; ALWAYS-NEXT:      (call $import)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $return-call-indirect_4 (type $i) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call_indirect $table (type $i)
+;; ALWAYS-NEXT:      (call $import)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $return-call-indirect_3 (type $i) (result i32)
+;; CAREFUL-NEXT:  (i32.const 1)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $return-call-indirect_4 (type $i) (result i32)
+;; CAREFUL-NEXT:  (return_call_indirect $table (type $i)
+;; CAREFUL-NEXT:   (call $import)
+;; CAREFUL-NEXT:  )
+;; CAREFUL-NEXT: )
+(module
+  ;; ALWAYS:      (type $i (func (result i32)))
+  ;; CAREFUL:      (type $i (func (result i32)))
+  (type $i (func (result i32)))
+
+  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))
+
+  ;; ALWAYS:      (import "a" "c" (func $import (type $i) (result i32)))
+  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))
+
+  ;; CAREFUL:      (import "a" "c" (func $import (type $i) (result i32)))
+  (import "a" "c" (func $import (result i32)))
+
+  ;; ALWAYS:      (table $table 10 10 funcref)
+  ;; CAREFUL:      (table $table 10 10 funcref)
+  (table $table 10 10 funcref)
+
+  ;; ALWAYS:      (elem declare func $import)
+
+  ;; ALWAYS:      (func $return-call-ref (type $1) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call_ref $i
+  ;; ALWAYS-NEXT:     (ref.func $import)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (i32.const 1)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (elem declare func $import)
+
+  ;; CAREFUL:      (func $return-call-ref (type $1) (param $0 i32) (result i32)
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $0)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call $import)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (i32.const 1)
+  ;; CAREFUL-NEXT: )
+  (func $return-call-ref (param $x i32) (result i32)
+    ;; As above, but now with a return_call_ref. The outcome below is similar.
+    (if
+      (local.get $x)
+      (then
+        (return_call_ref $i
+          (ref.func $import)
+        )
+      )
+    )
+    (i32.const 1)
+  )
+
+  ;; ALWAYS:      (func $call-return-call-ref (type $1) (param $x i32) (result i32)
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-ref_3)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-ref_4)
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (drop
+  ;; ALWAYS-NEXT:   (call $return-call-ref
+  ;; ALWAYS-NEXT:    (local.get $x)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call $import)
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call_indirect $table (type $i)
+  ;; ALWAYS-NEXT:     (i32.const 7)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (if
+  ;; ALWAYS-NEXT:   (local.get $x)
+  ;; ALWAYS-NEXT:   (then
+  ;; ALWAYS-NEXT:    (return_call_ref $i
+  ;; ALWAYS-NEXT:     (ref.func $import)
+  ;; ALWAYS-NEXT:    )
+  ;; ALWAYS-NEXT:   )
+  ;; ALWAYS-NEXT:  )
+  ;; ALWAYS-NEXT:  (unreachable)
+  ;; ALWAYS-NEXT: )
+  ;; CAREFUL:      (func $call-return-call-ref (type $1) (param $x i32) (result i32)
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-ref_3)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-ref_4)
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (drop
+  ;; CAREFUL-NEXT:   (call $return-call-ref
+  ;; CAREFUL-NEXT:    (local.get $x)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call $import)
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call_indirect $table (type $i)
+  ;; CAREFUL-NEXT:     (i32.const 7)
+  ;; CAREFUL-NEXT:    )
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (if
+  ;; CAREFUL-NEXT:   (local.get $x)
+  ;; CAREFUL-NEXT:   (then
+  ;; CAREFUL-NEXT:    (return_call_ref $i
+  ;; CAREFUL-NEXT:     (ref.func $import)
+  ;; CAREFUL-NEXT:    )
+  ;; CAREFUL-NEXT:   )
+  ;; CAREFUL-NEXT:  )
+  ;; CAREFUL-NEXT:  (unreachable)
+  ;; CAREFUL-NEXT: )
+  (func $call-return-call-ref (param $x i32) (result i32)
+    ;; As before, a set of three calls (with similar outcomes as before: the
+    ;; first two are monomorphized without the drop; the last is unchanged).
+    (drop
+      (call $return-call-ref
+        (i32.const 0)
+      )
+    )
+    (drop
+      (call $return-call-ref
+        (i32.const 1)
+      )
+    )
+    (drop
+      (call $return-call-ref
+        (local.get $x)
+      )
+    )
+
+    ;; Also add some return calls here, to show that it is fine for the caller
+    ;; to have them: we can still monomorphize some of the previous calls
+    ;; (without their drops).
+    (if
+      (local.get $x)
+      (then
+        (return_call $import)
+      )
+    )
+    (if
+      (local.get $x)
+      (then
+        (return_call_indirect (type $i)
+          (i32.const 7)
+        )
+      )
+    )
+    (if
+      (local.get $x)
+      (then
+        (return_call_ref $i
+          (ref.func $import)
+        )
+      )
+    )
+    (unreachable)
+  )
+)
+
+;; ALWAYS:      (func $return-call-ref_3 (type $i) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 0)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call_ref $i
+;; ALWAYS-NEXT:      (ref.func $import)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; ALWAYS:      (func $return-call-ref_4 (type $i) (result i32)
+;; ALWAYS-NEXT:  (local $x i32)
+;; ALWAYS-NEXT:  (local.set $x
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT:  (block (result i32)
+;; ALWAYS-NEXT:   (if
+;; ALWAYS-NEXT:    (local.get $x)
+;; ALWAYS-NEXT:    (then
+;; ALWAYS-NEXT:     (return_call_ref $i
+;; ALWAYS-NEXT:      (ref.func $import)
+;; ALWAYS-NEXT:     )
+;; ALWAYS-NEXT:    )
+;; ALWAYS-NEXT:   )
+;; ALWAYS-NEXT:   (i32.const 1)
+;; ALWAYS-NEXT:  )
+;; ALWAYS-NEXT: )
+
+;; CAREFUL:      (func $return-call-ref_3 (type $i) (result i32)
+;; CAREFUL-NEXT:  (i32.const 1)
+;; CAREFUL-NEXT: )
+
+;; CAREFUL:      (func $return-call-ref_4 (type $i) (result i32)
+;; CAREFUL-NEXT:  (return_call $import)
+;; CAREFUL-NEXT: )