Fix deinit against uninited InstanceEntity

Author: kateinoigakukun

Sources/WasmKit/Execution/Instances.swift

@@ -78,6 +78,21 @@ struct InstanceEntity /* : ~Copyable */ {
     var exports: [String: InternalExternalValue]
     var features: WasmFeatureSet
     var hasDataCount: Bool
+
+    static var empty: InstanceEntity {
+        InstanceEntity(
+            types: [],
+            functions: ImmutableArray(),
+            tables: ImmutableArray(),
+            memories: ImmutableArray(),
+            globals: ImmutableArray(),
+            elementSegments: ImmutableArray(),
+            dataSegments: ImmutableArray(),
+            exports: [:],
+            features: [],
+            hasDataCount: false
+        )
+    }
 }
 
 typealias InternalInstance = EntityHandle<InstanceEntity>

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -106,6 +106,11 @@ struct ImmutableArray<T> {
         buffer = UnsafeBufferPointer(mutable)
     }
 
+    /// Initializes an empty immutable array.
+    init() {
+        buffer = UnsafeBufferPointer(start: nil, count: 0)
+    }
+
     /// Accesses the element at the specified position.
     subscript(index: Int) -> T {
         buffer[index]
@@ -254,9 +259,6 @@ extension StoreAllocator {
         // Step 1 of module allocation algorithm, according to Wasm 2.0 spec.
 
         let types = module.types
-        // Uninitialized instance
-        let instancePointer = instances.allocate()
-        let instanceHandle = InternalInstance(unsafe: instancePointer)
         var importedFunctions: [InternalFunction] = []
         var importedTables: [InternalTable] = []
         var importedMemories: [InternalMemory] = []
@@ -318,6 +320,20 @@ extension StoreAllocator {
             }
         }
 
+        // Uninitialized instance
+        let instancePointer = instances.allocate()
+        var instanceInitialized = false
+        defer {
+            // If the instance is not initialized due to an exception, initialize it with an empty instance
+            // to allow bump deallocation by the bump allocator.
+            // This is not optimal as it leaves an empty instance without deallocating the space but
+            // good at code simplicity.
+            if !instanceInitialized {
+                instancePointer.initialize(to: .empty)
+            }
+        }
+        let instanceHandle = InternalInstance(unsafe: instancePointer)
+
         // Step 2.
         let functions = allocateEntities(
             imports: importedFunctions,
@@ -430,6 +446,7 @@ extension StoreAllocator {
             hasDataCount: module.hasDataCount
         )
         instancePointer.initialize(to: instanceEntity)
+        instanceInitialized = true
         return instanceHandle
     }