Use shared_from_this to avoid lifetime issues with ModuleRunner

Author: stevenfontanella

scripts/test/shared.py

@@ -477,7 +477,7 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'imports0.wast',        # Missing memory type validation on instantiation
     'imports2.wast',        # Missing memory type validation on instantiation
     'imports3.wast',        # Missing memory type validation on instantiation
-    'linking0.wast',        # Missing memory type validation on instantiation
+    # 'linking0.wast',        # Missing memory type validation on instantiation
     'linking3.wast',        # Fatal error on missing table.
     'i16x8_relaxed_q15mulr_s.wast',  # Requires wast `either` support
     'i32x4_relaxed_trunc.wast',      # Requires wast `either` support

src/wasm-interpreter.h

@@ -86,7 +86,7 @@ class Flow {
   }
 
   Literals values;
-  Name breakTo; // if non-null, a break is going on
+  Name breakTo;              // if non-null, a break is going on
   Tag* suspendTag = nullptr; // if non-null, breakTo must be SUSPEND_FLOW, and
                              // this is the tag being suspended
 
@@ -137,10 +137,9 @@ struct FuncData {
 
   // The interpreter instance this function closes over, if any. (There might
   // not be an interpreter instance if this is a host function or an import from
-  // an unknown source.) This is only used for equality comparisons, as two
-  // functions are equal iff they have the same name and are defined by the same
-  // instance (in particular, we do *not* compare the |call| field below, which
-  // is an execution detail).
+  // an unknown source.) Two functions are equal iff they have the same name and
+  // are defined by the same instance (in particular, we do *not* compare the
+  // |call| field below, which is an execution detail).
   void* self;
 
   // A way to execute this function. We use this when it is called.
@@ -4999,24 +4998,25 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   std::map<Name, std::shared_ptr<SubType>> linkedInstances;
 };
 
-class ModuleRunner : public ModuleRunnerBase<ModuleRunner> {
+class ModuleRunner : public ModuleRunnerBase<ModuleRunner>,
+                     public std::enable_shared_from_this<ModuleRunner> {
 public:
   ModuleRunner(
     Module& wasm,
     ExternalInterface* externalInterface,
     std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances = {})
     : ModuleRunnerBase(wasm, externalInterface, linkedInstances) {}
 
+  // As the super's |makeFuncData|, but here we also provide a way to
+  // actually call the function.
   Literal makeFuncData(Name name, Type type) {
-    // As the super's |makeFuncData|, but here we also provide a way to
-    // actually call the function.
-    auto allocation =
-      std::make_shared<FuncData>(name, this, [this, name](Literals arguments) {
-        return callFunction(name, arguments);
+    // This function may outlive the ModuleRunner in the case that instantiation
+    // fails. Use shared_from_this() to extend this ModuleRunner's lifetime.
+    auto allocation = std::make_shared<FuncData>(
+      name, this, [self = shared_from_this(), name](Literals arguments) {
+        return self->callFunction(name, arguments);
       });
-#if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
-    __lsan_ignore_object(allocation.get());
-#endif
+
     return Literal(allocation, type);
   }
 };