miri: Fix a new code pattern with stacked borrows (#11019)

Joel and I went down a deep rabbit hole today trying to figure out
what's going on with a new code pattern which was being flagged as
violating stacked borrows. At the end of the day I'm honestly not 100%
sure what this doing or how to explain all the behavior we were seeing,
but this seems to be basically equivalent and we're otherwise able to
get a bit further so I figured I'd commit this.

Along the way I updated the preexisting `table-intrinsics` test to
correctly use the table it was supposed to be using instead of using the
previous table by accident.

Author: alexcrichton

crates/wasmtime/src/runtime/vm/table.rs

@@ -957,25 +957,19 @@ impl Table {
             },
             Table::Dynamic(DynamicTable::Func(DynamicFuncTable { elements, .. })) => {
                 VMTableDefinition {
-                    base: NonNull::<[FuncTableElem]>::from(&mut elements[..])
-                        .cast()
-                        .into(),
+                    base: NonNull::new(elements.as_mut_ptr()).unwrap().cast().into(),
                     current_elements: elements.len(),
                 }
             }
             Table::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => {
                 VMTableDefinition {
-                    base: NonNull::<[Option<VMGcRef>]>::from(&mut elements[..])
-                        .cast()
-                        .into(),
+                    base: NonNull::new(elements.as_mut_ptr()).unwrap().cast().into(),
                     current_elements: elements.len(),
                 }
             }
             Table::Dynamic(DynamicTable::Cont(DynamicContTable { elements, .. })) => {
                 VMTableDefinition {
-                    base: NonNull::<[Option<VMContObj>]>::from(&mut elements[..])
-                        .cast()
-                        .into(),
+                    base: NonNull::new(elements.as_mut_ptr()).unwrap().cast().into(),
                     current_elements: elements.len(),
                 }
             }

tests/all/pulley.rs

@@ -181,6 +181,9 @@ fn pulley_provenance_test() -> Result<()> {
     instance
         .get_typed_func::<(), ()>(&mut store, "table-intrinsics")?
         .call(&mut store, ())?;
+    instance
+        .get_typed_func::<(), ()>(&mut store, "table-intrinsics2")?
+        .call(&mut store, ())?;
 
     let funcref = Func::wrap(&mut store, move |mut caller: Caller<'_, ()>| {
         let func = instance.get_typed_func::<(), (i32, i32, i32)>(&mut caller, "call-wasm")?;

tests/all/pulley_provenance_test.wat

@@ -67,20 +67,27 @@
   )
   (data $d "abcd")
 
-  (table 1 funcref)
+  (table $t 1 funcref)
   (func (export "table-intrinsics")
-    (drop (table.get (i32.const 0)))
-    (table.set (i32.const 0) (table.get (i32.const 0)))
+    (drop (table.get $t (i32.const 0)))
+    (table.set $t (i32.const 0) (table.get $t (i32.const 0)))
 
-    (drop (table.grow (ref.null func) (i32.const 100)))
+    (drop (table.grow $t (ref.null func) (i32.const 100)))
 
-    (drop (table.get (i32.const 1)))
-    (table.set (i32.const 1) (table.get (i32.const 1)))
+    (drop (table.get $t (i32.const 1)))
+    (table.set $t (i32.const 1) (table.get $t (i32.const 1)))
 
-    (table.copy (i32.const 0) (i32.const 1) (i32.const 10))
-    (table.init $e (i32.const 0) (i32.const 1) (i32.const 3))
-    (table.fill (i32.const 0) (ref.func $empty) (i32.const 10))
+    (table.copy $t $t (i32.const 0) (i32.const 1) (i32.const 10))
+    (table.init $t $e (i32.const 0) (i32.const 1) (i32.const 3))
+    (table.fill $t (i32.const 0) (ref.func $empty) (i32.const 10))
   )
   (elem $e func $empty $empty $empty $empty)
   (func $empty)
+
+  (table $t2 2 funcref)
+  (elem (table $t2) (i32.const 0) func $empty)
+  (func (export "table-intrinsics2")
+    (drop (table.get $t2 (i32.const 1)))
+    (drop (table.get $t2 (i32.const 0)))
+  )
 )