[wasm-split] Split module elements early (#8688)

Before #8443, we scanned `ref.func`s in global initializers early in
`indirectReferencesToSecondaryFunctions` and created trampolines for
them and replaced `ref.func $func`s with `ref.func $trampoline_func` if
`func` was set to move to a secondary module. But in case the global
containing `ref.func $trampoline_func` also ends up moving to the same
secondary module, creating trampoline and using it was not necessary,
because the global can simply use `ref.func $func` because `func` is in
the same secondary module.

To fix this, in #8443, we postponed creating trampolines for `ref.func`s
in global initializers until `shareImportableItems`. This had a problem,
because we end up creating new trampolines late in
`shareImportableItems`. But trampolines were designed to go through
`indirectCallsToSecondaryFunctions` and `setupTablePatching`, so those
late trampolines were invalid, like
```wast
(func $trampoline_foo
  (call $foo)
)
```
when `foo` was in a secondary module. This was supposed to be converted
to a `call_indirect` in `indirectCallsToSecondaryFunctions` and the
table elements were supposed to set up in `setupTablePatching`.

---

This moves `shareImportableItems` before
`indirectReferencesToSecondaryFunctions`. Turns out, except for the
active table and its base global, we can do all splitting before we make
most of the changes related to splitting. This also simplifies
`shareImportableItems` because we can now delete code handling the
consequences of various transformations.

Because the active table and its base global may not be registered as
"used" in `shareImportableItems` before `setupTablePatching`, we make
sure they are correctly shared with secondary modules in
`setupTablePatching`.

`active-table-base-global-used-elsewhere.wast` has some edge cases that
I feel easy to miss, because now we specially handle the active table
and the base global in `setupTablePatching`. `global-reffunc.wast` is
the same but just renamed expectation rewritten. `global-reffunc2.wast`
is the failing case simplified from #8510. Other test changes are just
the changes in the creation order of module elements and not meaningful.

Replaces #8542 and fixes #8510.

Author: aheejin

scripts/fuzz_opt.py

@@ -2525,7 +2525,7 @@ def handle(self, wasm):
     TrapsNeverHappen(),
     CtorEval(),
     Merge(),
-    # Split(), # https://github.com/WebAssembly/binaryen/issues/8510
+    Split(),
     RoundtripText(),
     ClusterFuzz(),
     Two(),

src/ir/module-splitting.cpp

@@ -0,0 +1,63 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+;; We need to disable reference-types to reuse the existing table as the active
+;; table
+;; RUN: wasm-split %s --disable-reference-types --split-funcs=split -g -o1 %t.1.wasm -o2 %t.2.wasm
+;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY
+;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY
+
+;; This tests the case when an existing table is used as the active table, and
+;; the active table and its base global already has existing uses in the
+;; secondary module.
+
+(module
+ ;; PRIMARY:      (type $0 (func))
+ ;; SECONDARY:      (type $0 (func))
+ (type $0 (func))
+ (global $base (import "env" "base") i32)
+ ;; PRIMARY:      (import "env" "base" (global $base i32))
+
+ ;; PRIMARY:      (import "placeholder.deferred" "1" (func $placeholder_1))
+
+ ;; PRIMARY:      (table $table 2 funcref)
+ (table $table 1 funcref)
+ (elem (global.get $base) $keep)
+ ;; PRIMARY:      (elem $0 (global.get $base) $keep $placeholder_1)
+
+ ;; PRIMARY:      (export "table" (table $table))
+
+ ;; PRIMARY:      (export "global" (global $base))
+
+ ;; PRIMARY:      (export "keep" (func $keep))
+
+ ;; PRIMARY:      (func $keep
+ ;; PRIMARY-NEXT:  (call_indirect (type $0)
+ ;; PRIMARY-NEXT:   (i32.add
+ ;; PRIMARY-NEXT:    (global.get $base)
+ ;; PRIMARY-NEXT:    (i32.const 1)
+ ;; PRIMARY-NEXT:   )
+ ;; PRIMARY-NEXT:  )
+ ;; PRIMARY-NEXT: )
+ (func $keep
+  (call $split)
+ )
+ ;; SECONDARY:      (import "primary" "table" (table $table 1 funcref))
+
+ ;; SECONDARY:      (import "primary" "global" (global $base i32))
+
+ ;; SECONDARY:      (import "primary" "keep" (func $keep))
+
+ ;; SECONDARY:      (elem $0 (global.get $base) $keep $split)
+
+ ;; SECONDARY:      (func $split
+ ;; SECONDARY-NEXT:  (drop
+ ;; SECONDARY-NEXT:   (global.get $base)
+ ;; SECONDARY-NEXT:  )
+ ;; SECONDARY-NEXT:  (call_indirect (type $0)
+ ;; SECONDARY-NEXT:   (i32.const 0)
+ ;; SECONDARY-NEXT:  )
+ ;; SECONDARY-NEXT: )
+ (func $split
+  (drop (global.get $base))
+  (call_indirect (type $0) (i32.const 0))
+ )
+)

test/lit/wasm-split/active-table-base-global-used-elsewhere.wast

@@ -0,0 +1,45 @@
+;; RUN: wasm-split %s -all -g -o1 %t.1.wasm -o2 %t.2.wasm --keep-funcs=keep
+;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY
+;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY
+
+;; When a split global ($a here)'s initializer contains a ref.func of a split
+;; function, we should NOT create any trampolines, and the split global should
+;; directly refer to the function.
+
+(module
+  (global $a funcref (ref.func $split))
+  (global $b funcref (ref.func $keep))
+
+  (func $keep)
+
+  (func $split
+    (drop
+      (global.get $a)
+    )
+    (drop
+      (global.get $b)
+    )
+  )
+)
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (export "keep" (func $keep))
+;; PRIMARY-NEXT:  (func $keep
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY:      (module
+;; SECONDARY-NEXT:  (type $0 (func))
+;; SECONDARY-NEXT:  (import "primary" "keep" (func $keep (exact)))
+;; SECONDARY-NEXT:  (global $a funcref (ref.func $split))
+;; SECONDARY-NEXT:  (global $b funcref (ref.func $keep))
+;; SECONDARY-NEXT:  (func $split
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $a)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $b)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:  )
+;; SECONDARY-NEXT: )

test/lit/wasm-split/global-funcref.wast

@@ -0,0 +1,52 @@
+;; RUN: wasm-split %s -all -g -o1 %t.1.wasm -o2 %t.2.wasm --split-funcs=split1,split2
+;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY
+;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY
+
+;; Global $g1 is used (exported) in the primary module so it can't move, and
+;; global $g2 is only used in the secondary module so it will move there.
+
+(module
+  (global $g1 funcref (ref.func $split1))
+  (global $g2 funcref (ref.func $split2))
+  (export "g1" (global $g1))
+
+  (func $split1
+    (unreachable)
+  )
+
+  (func $split2
+    (drop
+      (global.get $g2)
+    )
+  )
+)
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (import "placeholder.deferred" "0" (func $placeholder_0))
+;; PRIMARY-NEXT:  (global $g1 funcref (ref.func $trampoline_split1))
+;; PRIMARY-NEXT:  (table $0 1 funcref)
+;; PRIMARY-NEXT:  (elem $0 (i32.const 0) $placeholder_0)
+;; PRIMARY-NEXT:  (export "g1" (global $g1))
+;; PRIMARY-NEXT:  (export "table" (table $0))
+;; PRIMARY-NEXT:  (func $trampoline_split1
+;; PRIMARY-NEXT:   (call_indirect (type $0)
+;; PRIMARY-NEXT:    (i32.const 0)
+;; PRIMARY-NEXT:   )
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY:      (module
+;; SECONDARY-NEXT:  (type $0 (func))
+;; SECONDARY-NEXT:  (import "primary" "table" (table $timport$0 1 funcref))
+;; SECONDARY-NEXT:  (global $g2 funcref (ref.func $split2))
+;; SECONDARY-NEXT:  (elem $0 (i32.const 0) $split1)
+;; SECONDARY-NEXT:  (func $split1
+;; SECONDARY-NEXT:   (unreachable)
+;; SECONDARY-NEXT:  )
+;; SECONDARY-NEXT:  (func $split2
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $g2)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:  )
+;; SECONDARY-NEXT: )

test/lit/wasm-split/global-reffunc.wast

@@ -73,7 +73,7 @@
 
  ;; SECONDARY:      (import "primary" "prime" (func $prime (exact (type $0))))
 
- ;; SECONDARY:      (elem $0 (i32.const 0) $second-in-table $second)
+ ;; SECONDARY:      (elem $0 (i32.const 0) $second $second-in-table)
 
  ;; SECONDARY:      (elem declare func $prime)
 
@@ -109,13 +109,13 @@
   ;; (but we will get a placeholder, as all split-out functions do).
  )
 )
-;; PRIMARY:      (func $trampoline_second-in-table (type $0)
+;; PRIMARY:      (func $trampoline_second (type $0)
 ;; PRIMARY-NEXT:  (call_indirect $1 (type $0)
 ;; PRIMARY-NEXT:   (i32.const 0)
 ;; PRIMARY-NEXT:  )
 ;; PRIMARY-NEXT: )
 
-;; PRIMARY:      (func $trampoline_second (type $0)
+;; PRIMARY:      (func $trampoline_second-in-table (type $0)
 ;; PRIMARY-NEXT:  (call_indirect $1 (type $0)
 ;; PRIMARY-NEXT:   (i32.const 1)
 ;; PRIMARY-NEXT:  )

test/lit/wasm-split/global-reffunc2.wast

@@ -34,16 +34,16 @@
  ;; PRIMARY:      (tag $keep-tag (type $1) (param i32))
  ;; PRIMARY-NEXT: (tag $shared-tag (type $1) (param i32))
 
- ;; PRIMARY:      (export "keep" (func $keep))
- ;; PRIMARY-NEXT: (export "memory" (memory $shared-memory))
+ ;; PRIMARY:      (export "memory" (memory $shared-memory))
  ;; PRIMARY-NEXT: (export "table" (table $shared-table))
- ;; PRIMARY-NEXT: (export "table_3" (table $2))
  ;; PRIMARY-NEXT: (export "global" (global $shared-global))
  ;; PRIMARY-NEXT: (export "tag" (tag $shared-tag))
+ ;; PRIMARY-NEXT: (export "keep" (func $keep))
+ ;; PRIMARY-NEXT: (export "table_5" (table $2))
 
  ;; SECONDARY:      (import "primary" "memory" (memory $shared-memory 1 1))
- ;; SECONDARY-NEXT: (import "primary" "table_3" (table $timport$0 1 funcref))
  ;; SECONDARY-NEXT: (import "primary" "table" (table $shared-table 1 1 funcref))
+ ;; SECONDARY-NEXT: (import "primary" "table_5" (table $timport$1 1 funcref))
  ;; SECONDARY-NEXT: (import "primary" "global" (global $shared-global i32))
  ;; SECONDARY-NEXT: (import "primary" "keep" (func $keep (exact (param i32) (result i32))))
  ;; SECONDARY-NEXT: (import "primary" "tag" (tag $shared-tag (type $1) (param i32)))