[dart2wasm] Add asserts ensuring exportable entities are only directly accessed from their own modules.

Change-Id: Ia5d5493e4db2710164d6966e97a0854fe2582f28
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/391860
Commit-Queue: Nate Biggs <[email protected]>
Reviewed-by: Ömer Ağacan <[email protected]>

Author: natebiggs

pkg/wasm_builder/lib/src/builder/instructions.dart

@@ -552,6 +552,7 @@ class InstructionsBuilder with Builder<ir.Instructions> {
     final Try try_ = _topOfLabelStack as Try;
     assert(_verifyEndOfBlock(tag.type.inputs,
         trace: ['catch', tag], reachableAfter: try_.reachable, reindent: true));
+    assert(tag.enclosingModule == module);
     try_.hasCatch = true;
     _reachable = try_.reachable;
     _add(ir.Catch(tag));
@@ -571,6 +572,7 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   /// Emit a `throw` instruction.
   void throw_(ir.Tag tag) {
     assert(_verifyTypes(tag.type.inputs, const [], trace: ['throw', tag]));
+    assert(tag.enclosingModule == module);
     _add(ir.Throw(tag));
     _reachable = false;
   }
@@ -650,6 +652,7 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   void call_indirect(ir.FunctionType type, [ir.Table? table]) {
     assert(_verifyTypes([...type.inputs, ir.NumType.i32], type.outputs,
         trace: ['call_indirect', type, if (table != null) table.name]));
+    assert(table == null || table.enclosingModule == module);
     _add(ir.CallIndirect(type, table));
   }
 
@@ -716,6 +719,7 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   void global_get(ir.Global global) {
     assert(_verifyTypes(const [], [global.type.type],
         trace: ['global.get', global]));
+    assert(global.enclosingModule == module);
     _add(ir.GlobalGet(global));
   }
 
@@ -724,6 +728,7 @@ class InstructionsBuilder with Builder<ir.Instructions> {
     assert(global.type.mutable);
     assert(_verifyTypes([global.type.type], const [],
         trace: ['global.set', global]));
+    assert(global.enclosingModule == module);
     _add(ir.GlobalSet(global));
   }
 
@@ -733,30 +738,35 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   void table_get(ir.Table table) {
     assert(_verifyTypes(const [ir.NumType.i32], [table.type],
         trace: ['table.get', table.name]));
+    assert(table.enclosingModule == module);
     _add(ir.TableGet(table));
   }
 
   /// Emit a `table.set` instruction.
   void table_set(ir.Table table) {
     assert(_verifyTypes([ir.NumType.i32, table.type], const [],
         trace: ['table.set', table.name]));
+    assert(table.enclosingModule == module);
     _add(ir.TableSet(table));
   }
 
   /// Emit a `table.size` instruction.
   void table_size(ir.Table table) {
     assert(_verifyTypes(const [], const [ir.NumType.i32],
         trace: ['table.size', table.name]));
+    assert(table.enclosingModule == module);
     _add(ir.TableSize(table));
   }
 
   // Memory instructions
   void _addMemoryInstruction(
-          ir.Instruction Function(ir.MemoryOffsetAlign memory) create,
-          ir.Memory memory,
-          {required int offset,
-          required int align}) =>
-      _add(create(ir.MemoryOffsetAlign(memory, offset: offset, align: align)));
+      ir.Instruction Function(ir.MemoryOffsetAlign memory) create,
+      ir.Memory memory,
+      {required int offset,
+      required int align}) {
+    assert(memory.enclosingModule == module);
+    _add(create(ir.MemoryOffsetAlign(memory, offset: offset, align: align)));
+  }
 
   /// Emit an `i32.load` instruction.
   void i32_load(ir.Memory memory, int offset, [int align = 2]) {
@@ -964,12 +974,14 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   /// Emit a `memory.size` instruction.
   void memory_size(ir.Memory memory) {
     assert(_verifyTypes(const [], const [ir.NumType.i32]));
+    assert(memory.enclosingModule == module);
     _add(ir.MemorySize(memory));
   }
 
   /// Emit a `memory.grow` instruction.
   void memory_grow(ir.Memory memory) {
     assert(_verifyTypes(const [ir.NumType.i32], const [ir.NumType.i32]));
+    assert(memory.enclosingModule == module);
     _add(ir.MemoryGrow(memory));
   }