Make const-expr evaluation async

This commit is extracted from bytecodealliance#11430 to accurately reflect how
const-expr evaluation is an async operation due to GC pauses that may
happen. The changes in this commit are:

* Const-expr evaluation is, at its core, now an `async` function.
* To leverage this new `async`-ness all internal operations are switched
  from `*_maybe_async` to `*_async` meaning all the `*_maybe_async`
  methods can be removed.
* Some libcalls using `*_maybe_async` are switch to using `*_async` plus
  the `block_on!` utility to help jettison more `*_maybe_async` methods.
* Instance initialization is now an `async` function. This is
  temporarily handled with `block_on` during instance initialization to
  avoid propagating the `async`-ness further upwards. This `block_on`
  will get deleted in future refactorings.
* Const-expr evaluation has been refactored slightly to enable having a
  fast path in global initialization which skips an `await` point
  entirely, achieving performance-parity in benchmarks prior to this commit.

This ended up fixing a niche issue with GC where if a wasm execution was
suspended during `table.init`, for example, during a const-expr
evaluation triggering a GC then if the wasm execution was cancelled it
would panic the host. This panic was because the GC operation returned
`Result` but it was `unwrap`'d as part of the const-expr evaluation
which can fail not only to invalid-ness but also due to "computation is
cancelled" traps.

Author: alexcrichton

crates/wasmtime/src/runtime/vm/instance/allocator.rs

@@ -387,48 +387,28 @@ impl dyn InstanceAllocator + '_ {
         self.increment_core_instance_count()?;
 
         let num_defined_memories = module.num_defined_memories();
-        let num_defined_tables = module.num_defined_tables();
-
-        let mut guard = DeallocateOnDrop {
-            run_deallocate: true,
-            memories: PrimaryMap::with_capacity(num_defined_memories),
-            tables: PrimaryMap::with_capacity(num_defined_tables),
-            allocator: self,
-        };
-
-        self.allocate_memories(&mut request, &mut guard.memories)?;
-        self.allocate_tables(&mut request, &mut guard.tables)?;
-        guard.run_deallocate = false;
-        // SAFETY: memories/tables were just allocated from the store within
-        // `request` and this function's own contract requires that the
-        // imports are valid.
-        return unsafe {
-            Ok(Instance::new(
-                request,
-                mem::take(&mut guard.memories),
-                mem::take(&mut guard.tables),
-                &module.memories,
-            ))
-        };
-
-        struct DeallocateOnDrop<'a> {
-            run_deallocate: bool,
-            memories: PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
-            tables: PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
-            allocator: &'a (dyn InstanceAllocator + 'a),
-        }
+        let mut memories = PrimaryMap::with_capacity(num_defined_memories);
 
-        impl Drop for DeallocateOnDrop<'_> {
-            fn drop(&mut self) {
-                if !self.run_deallocate {
-                    return;
-                }
+        let num_defined_tables = module.num_defined_tables();
+        let mut tables = PrimaryMap::with_capacity(num_defined_tables);
+
+        match (|| {
+            self.allocate_memories(&mut request, &mut memories)?;
+            self.allocate_tables(&mut request, &mut tables)?;
+            Ok(())
+        })() {
+            // SAFETY: memories/tables were just allocated from the store within
+            // `request` and this function's own contract requires that the
+            // imports are valid.
+            Ok(_) => unsafe { Ok(Instance::new(request, memories, tables, &module.memories)) },
+            Err(e) => {
                 // SAFETY: these were previously allocated by this allocator
                 unsafe {
-                    self.allocator.deallocate_memories(&mut self.memories);
-                    self.allocator.deallocate_tables(&mut self.tables);
+                    self.deallocate_memories(&mut memories);
+                    self.deallocate_tables(&mut tables);
                 }
-                self.allocator.decrement_core_instance_count();
+                self.decrement_core_instance_count();
+                Err(e)
             }
         }
     }