Set an absolute maximum inlining limit

src/ir/utils.h

@@ -33,11 +33,17 @@ struct Measurer
 
   void visitExpression(Expression* curr) { size++; }
 
+  // Measure the number of expressions.
   static Index measure(Expression* tree) {
     Measurer measurer;
     measurer.walk(tree);
     return measurer.size;
   }
+
+  // A rough estimate of average binary size per expression. The number here is
+  // based on measurements on real-world (MVP) wasm files, on which observed
+  // ratios were 2.2 - 2.8.
+  static constexpr double BytesPerExpr = 2.5;
 };
 
 struct ExpressionAnalyzer {

src/passes/Inlining.cpp

@@ -420,6 +420,9 @@ struct Inlining : public Pass {
           continue;
         }
         Name inlinedName = inlinedFunction->name;
+        if (!canInlineInto(func->name, inlinedName)) {
+          continue;
+        }
 #ifdef INLINING_DEBUG
         std::cout << "inline " << inlinedName << " into " << func->name << '\n';
 #endif
@@ -446,6 +449,20 @@ struct Inlining : public Pass {
     // return whether we did any work
     return inlinedUses.size() > 0;
   }
+
+  // Checks if we are allowed to inline source into target.
+  bool canInlineInto(Name target, Name source) {
+    // We wish to avoid certain extremely-large sizes after inlining, as they
+    // may hit limits in VMs and/or slow down startup (measurements there
+    // indicate something like ~1 second to optimize a 100K function). See e.g.
+    // https://github.com/WebAssembly/binaryen/pull/3730#issuecomment-867939138
+    // https://github.com/emscripten-core/emscripten/issues/13899#issuecomment-825073344
+    auto combinedSize = infos[target].size + infos[source].size;
+    // Estimate the binary size from the number of instructions.
+    auto estimatedBinarySize = Measurer::BytesPerExpr * combinedSize;
+    const Index MaxCombinedBinarySize = 400 * 1024;
+    return estimatedBinarySize < MaxCombinedBinarySize;
+  }
 };
 
 Pass* createInliningPass() { return new Inlining(); }