[dart2wasm] Dynamic module shared constants.

Updates the main module to export constants accessible from dynamic modules. This includes the backing global store as well as the initialization function if the constant is 'lazy'. The dynamic module then imports these directly from the main module and does not need to duplicate any of the code.

Change-Id: I2154572688b1e913b720e400286e7fc305694c22
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/422343
Reviewed-by: Martin Kustermann <[email protected]>

Author: natebiggs

pkg/dart2wasm/lib/constants.dart

@@ -14,6 +14,8 @@ import 'package:wasm_builder/wasm_builder.dart' as w;
 import 'class_info.dart';
 import 'closures.dart';
 import 'code_generator.dart';
+import 'dynamic_module_kernel_metadata.dart'
+    show DynamicModuleConstantRepository;
 import 'dynamic_modules.dart';
 import 'param_info.dart';
 import 'translator.dart';
@@ -71,7 +73,10 @@ typedef ConstantCodeGenerator = void Function(w.InstructionsBuilder);
 class Constants {
   final Translator translator;
   final Map<Constant, ConstantInfo> constantInfo = {};
-  final Map<Constant, ConstantInfo> dynamicModuleConstantInfo = {};
+  late final Map<Constant, int>? dynamicMainModuleConstantId = (translator
+              .component.metadata[DynamicModuleConstantRepository.repositoryTag]
+          as DynamicModuleConstantRepository?)
+      ?.mapping[translator.component] ??= {};
   w.DataSegmentBuilder? int32Segment;
   late final ClassInfo typeInfo = translator.classInfo[translator.typeClass]!;
 
@@ -494,55 +499,106 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?>
       constant = constants._lowerTypeConstant(type);
     }
 
-    final cache = translator.dynamicModuleSupportEnabled &&
-            !translator.isMainModule(targetModule)
-        ? constants.dynamicModuleConstantInfo
-        : constants.constantInfo;
-    ConstantInfo? info = cache[constant];
+    ConstantInfo? info = constants.constantInfo[constant];
     if (info == null) {
       info = constant.accept(this);
       if (info != null) {
-        cache[constant] = info;
+        constants.constantInfo[constant] = info;
       }
     }
     return info;
   }
 
+  static String _dynamicModuleConstantExportName(int id) => '#c$id';
+  static String _dynamicModuleInitFunctionExportName(int id) => '#cf$id';
+
   ConstantInfo createConstant(
       Constant constant, w.RefType type, ConstantCodeGenerator generator,
       {bool lazy = false}) {
     assert(!type.nullable);
-    if (lazy || translator.dynamicModuleSupportEnabled) {
+
+    // This function is only called once per [Constant]. If we compile a
+    // dynamic module then the [dynamicModuleConstantIdMap] is pre-populated and
+    // we may find an export name. If we compile the main module, then the id
+    // will be `null`.
+    final dynamicModuleConstantIdMap = constants.dynamicMainModuleConstantId;
+    final mainModuleExportId = dynamicModuleConstantIdMap?[constant];
+    final isShareableAcrossModules = dynamicModuleConstantIdMap != null &&
+        constant.accept(_ConstantDynamicModuleSharedChecker(translator));
+    final needsRuntimeCanonicalization = isShareableAcrossModules &&
+        translator.isDynamicModule &&
+        mainModuleExportId == null;
+
+    if (lazy || needsRuntimeCanonicalization) {
       // Create uninitialized global and function to initialize it.
-      final global =
-          targetModule.globals.define(w.GlobalType(type.withNullability(true)));
-      global.initializer.ref_null(w.HeapType.none);
-      global.initializer.end();
+      final globalType = w.GlobalType(type.withNullability(true));
+      w.Global global;
+      w.BaseFunction initFunction;
+
       w.FunctionType ftype =
           translator.typesBuilder.defineFunction(const [], [type]);
-      final function = targetModule.functions.define(ftype, "$constant");
-      final b2 = function.body;
-      generator(b2);
-      if (translator.dynamicModuleSupportEnabled) {
-        final valueLocal = b2.addLocal(type);
-        constant.accept(ConstantCanonicalizer(translator, b2, valueLocal));
+
+      if (mainModuleExportId != null) {
+        global = targetModule.globals.import(translator.mainModule.moduleName,
+            _dynamicModuleConstantExportName(mainModuleExportId), globalType);
+        initFunction = targetModule.functions.import(
+            translator.mainModule.moduleName,
+            _dynamicModuleInitFunctionExportName(mainModuleExportId),
+            ftype);
+      } else {
+        final definedGlobal = global = targetModule.globals.define(globalType);
+        definedGlobal.initializer.ref_null(w.HeapType.none);
+        definedGlobal.initializer.end();
+
+        final function =
+            initFunction = targetModule.functions.define(ftype, "$constant");
+
+        if (isShareableAcrossModules) {
+          final exportId = dynamicModuleConstantIdMap[constant] =
+              dynamicModuleConstantIdMap.length;
+
+          targetModule.exports.export(
+              _dynamicModuleConstantExportName(exportId), definedGlobal);
+          targetModule.exports
+              .export(_dynamicModuleInitFunctionExportName(exportId), function);
+        }
+        final b2 = function.body;
+        generator(b2);
+        if (needsRuntimeCanonicalization) {
+          final valueLocal = b2.addLocal(type);
+          constant.accept(ConstantCanonicalizer(translator, b2, valueLocal));
+        }
+        w.Local temp = b2.addLocal(type);
+        b2.local_tee(temp);
+        b2.global_set(global);
+        b2.local_get(temp);
+        b2.end();
       }
-      w.Local temp = b2.addLocal(type);
-      b2.local_tee(temp);
-      b2.global_set(global);
-      b2.local_get(temp);
-      b2.end();
 
-      return ConstantInfo(constant, global, function);
+      return ConstantInfo(constant, global, initFunction);
     } else {
       // Create global with the constant in its initializer.
       assert(!constants.currentlyCreating);
-      constants.currentlyCreating = true;
-      final global =
-          targetModule.globals.define(w.GlobalType(type, mutable: false));
-      generator(global.initializer);
-      global.initializer.end();
-      constants.currentlyCreating = false;
+      final globalType = w.GlobalType(type, mutable: false);
+      w.Global global;
+      if (mainModuleExportId != null) {
+        global = targetModule.globals.import(translator.mainModule.moduleName,
+            _dynamicModuleConstantExportName(mainModuleExportId), globalType);
+      } else {
+        constants.currentlyCreating = true;
+        final definedGlobal = global = targetModule.globals.define(globalType);
+        generator(definedGlobal.initializer);
+        definedGlobal.initializer.end();
+        constants.currentlyCreating = false;
+
+        if (isShareableAcrossModules) {
+          final exportId = dynamicModuleConstantIdMap[constant] =
+              dynamicModuleConstantIdMap.length;
+
+          targetModule.exports.export(
+              _dynamicModuleConstantExportName(exportId), definedGlobal);
+        }
+      }
 
       return ConstantInfo(constant, global, null);
     }
@@ -651,6 +707,10 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?>
       args = supertype.typeArguments;
     }
 
+    // If the class ID is relative then it needs to be globalized when
+    // initializing the object which is a non-const operation.
+    lazy |= info.classId is RelativeClassId;
+
     return createConstant(constant, type, lazy: lazy, (b) {
       b.pushObjectHeaderFields(translator, info);
       for (int i = FieldIndex.objectFieldBase; i < fieldCount; i++) {
@@ -910,8 +970,8 @@ class ConstantCreator extends ConstantVisitor<ConstantInfo?>
 
     // The vtable for the target will be stored on a global in the target's
     // module.
-    final isLazy =
-        translator.moduleForReference(constant.targetReference) != targetModule;
+    final isLazy = translator.moduleForReference(constant.targetReference) !=
+        translator.mainModule;
     // The dummy struct must be declared before the constant global so that the
     // constant's initializer can reference it.
     final dummyStructGlobal = translator
@@ -1158,3 +1218,36 @@ List<int> _intToLittleEndianBytes(int i) {
 }
 
 String _intToBase64(int i) => base64.encode(_intToLittleEndianBytes(i));
+
+/// Resolves to true if the visited Constant is accessible from dynamic modules.
+///
+/// Constants that are accessible from dynamic modules should be:
+/// (1) Exported from the main module if they exist there and then imported
+/// into dynamic modules.
+/// (2) Runtime canonicalized by dynamic modules if they are not in the main
+/// module.
+class _ConstantDynamicModuleSharedChecker extends ConstantVisitor<bool>
+    with ConstantVisitorDefaultMixin<bool> {
+  final Translator translator;
+
+  _ConstantDynamicModuleSharedChecker(this.translator);
+
+  // TODO(natebiggs): Make this more precise by handling more specific
+  // constants.
+  @override
+  bool defaultConstant(Constant constant) => true;
+
+  @override
+  bool visitInstanceConstant(InstanceConstant constant) {
+    final cls = constant.classNode;
+    if (!cls.enclosingLibrary.isFromMainModule(translator.coreTypes)) {
+      return false;
+    }
+    if (cls == translator.wasmArrayClass ||
+        cls == translator.immutableWasmArrayClass) {
+      return true;
+    }
+    return constant.classNode.constructors.any(
+        (c) => c.isConst && c.isDynamicModuleCallable(translator.coreTypes));
+  }
+}

pkg/dart2wasm/lib/dynamic_module_kernel_metadata.dart

@@ -59,6 +59,39 @@ class DynamicModuleGlobalIdRepository extends MetadataRepository<int> {
   }
 }
 
+/// Repository for kernel constants.
+class DynamicModuleConstantRepository
+    extends MetadataRepository<Map<Constant, int>> {
+  static const repositoryTag = 'wasm.dynamic-modules.constants';
+
+  @override
+  final String tag = repositoryTag;
+
+  @override
+  final Map<TreeNode, Map<Constant, int>> mapping = {};
+
+  @override
+  Map<Constant, int> readFromBinary(Node node, BinarySource source) {
+    final length = source.readUInt30();
+    final Map<Constant, int> constants = {};
+    for (int i = 0; i < length; i++) {
+      final constant = source.readConstantReference();
+      final id = source.readUInt30();
+      constants[constant] = id;
+    }
+    return constants;
+  }
+
+  @override
+  void writeToBinary(Map<Constant, int> constants, Node node, BinarySink sink) {
+    sink.writeUInt30(constants.length);
+    constants.forEach((constant, id) {
+      sink.writeConstantReference(constant);
+      sink.writeUInt30(id);
+    });
+  }
+}
+
 class ClassMetadata {
   /// The class numbering ID assigned to this class.
   final int classId;
@@ -454,6 +487,7 @@ Future<(Component, JSMethods)> generateDynamicModuleComponent(
       optimizedMainComponentBytes.length, dynamicModuleComponentBytes);
   final newComponent = Component()
     ..addMetadataRepository(DynamicModuleGlobalIdRepository())
+    ..addMetadataRepository(DynamicModuleConstantRepository())
     ..addMetadataRepository(ProcedureAttributesMetadataRepository())
     ..addMetadataRepository(TableSelectorMetadataRepository())
     ..addMetadataRepository(DirectCallMetadataRepository())

pkg/dart2wasm/lib/dynamic_modules.dart

@@ -116,6 +116,7 @@ class DynamicMainModuleStrategy extends ModuleStrategy with KernelNodes {
       addPragma(lib, _mainModLibPragma, coreTypes);
     }
 
+    component.addMetadataRepository(DynamicModuleConstantRepository());
     component.addMetadataRepository(DynamicModuleGlobalIdRepository());
   }