use getImmediateFallthrough

Author: HerrCai0907

src/passes/TailCall.cpp

@@ -1,55 +1,63 @@
 
+#include "ir/properties.h"
 #include "pass.h"
 #include "wasm-traversal.h"
 #include "wasm.h"
+#include <stack>
 #include <vector>
 
 namespace wasm {
 
 namespace {
 
 struct Finder : TryDepthWalker<Finder> {
+  explicit Finder(const PassOptions& passOptions)
+    : TryDepthWalker<Finder>(), passOptions(passOptions) {}
+  const PassOptions& passOptions;
   std::vector<Call*> tailCalls;
   std::vector<CallIndirect*> tailCallIndirects;
-  void visitFunction(Function* curr) { checkTailCall(curr->body); }
-  void visitReturn(Return* curr) { checkTailCall(curr->value); }
-
-private:
-  void checkTailCall(Expression* expr) {
-    if (expr == nullptr) {
+  void visitFunction(Function* curr) {
+    if (passOptions.shrinkLevel > 0 && passOptions.optimizeLevel == 0) {
+      // When we more force on the binary size, add return_call will increase
+      // the code size.
       return;
     }
+    checkTailCall(curr->body);
+  }
+  void visitReturn(Return* curr) {
     if (tryDepth > 0) {
-      // We are in a try block, so we cannot optimize tail calls.
-      return;
-    }
-    if (auto* call = expr->dynCast<Call>()) {
-      if (!call->isReturn && call->type == getFunction()->getResults()) {
-        tailCalls.push_back(call);
-      }
-      return;
-    }
-    if (auto* call = expr->dynCast<CallIndirect>()) {
-      if (!call->isReturn && call->type == getFunction()->getResults()) {
-        tailCallIndirects.push_back(call);
-      }
-      return;
-    }
-    if (auto* block = expr->dynCast<Block>()) {
-      return checkTailCall(block->list);
-    }
-    if (auto* ifElse = expr->dynCast<If>()) {
-      checkTailCall(ifElse->ifTrue);
-      checkTailCall(ifElse->ifFalse);
+      // (return (call ...)) is not equal to (return_call ...) in try block
       return;
     }
+    checkTailCall(curr->value);
   }
-  void checkTailCall(ExpressionList const& exprs) {
-    if (exprs.empty()) {
-      return;
+
+private:
+  void checkTailCall(Expression* const curr) {
+    std::stack<Expression*> workList{};
+    workList.push(curr);
+    while (!workList.empty()) {
+      Expression* const target = workList.top();
+      workList.pop();
+      if (auto* call = target->dynCast<Call>()) {
+        if (!call->isReturn && call->type == getFunction()->getResults()) {
+          tailCalls.push_back(call);
+        }
+      } else if (auto* call = target->dynCast<CallIndirect>()) {
+        if (!call->isReturn && call->type == getFunction()->getResults()) {
+          tailCallIndirects.push_back(call);
+        }
+      } else if (auto* ifElse = target->dynCast<If>()) {
+        workList.push(ifElse->ifTrue);
+        workList.push(ifElse->ifFalse);
+      } else {
+        Expression* const next = Properties::getImmediateFallthrough(
+          target, passOptions, *getModule());
+        if (next != target) {
+          workList.push(next);
+        }
+      }
     }
-    checkTailCall(exprs.back());
-    return;
   }
 };
 
@@ -64,7 +72,7 @@ struct TailCallOptimizer : public Pass {
     if (!module->features.hasTailCall()) {
       return;
     }
-    Finder finder{};
+    Finder finder{getPassOptions()};
     finder.walkFunctionInModule(function, module);
     for (Call* call : finder.tailCalls) {
       if (!call->isReturn) {