[vm/shared] Enforce trivially-shareable constraint.

Ensure only trivially-shareable and typed data values can be placed in shared static fields.

BUG=#60825
TEST=ci

Change-Id: Ief75cbd3fbb5fa0ebe94aab9a32e1f1fa090bcc5
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/438940
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Aprelev <[email protected]>

Author: aam

pkg/vm/lib/modular/target/vm.dart

@@ -174,6 +174,7 @@ class VmTarget extends Target {
     ChangedStructureNotifier? changedStructureNotifier,
   }) {
     deeply_immutable.validateLibraries(
+      component,
       libraries,
       coreTypes,
       diagnosticReporter,

pkg/vm/lib/modular/transformations/deeply_immutable.dart

@@ -13,14 +13,23 @@ import 'package:front_end/src/codes/cfe_codes.dart'
         messageFfiDeeplyImmutableSupertypeMustBeDeeplyImmutable;
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';
+import 'package:kernel/library_index.dart' show LibraryIndex;
 import 'package:kernel/target/targets.dart' show DiagnosticReporter;
 
 void validateLibraries(
+  Component component,
   List<Library> libraries,
   CoreTypes coreTypes,
   DiagnosticReporter diagnosticReporter,
 ) {
-  final validator = DeeplyImmutableValidator(coreTypes, diagnosticReporter);
+  final LibraryIndex index = LibraryIndex(component, const [
+    'dart:nativewrappers',
+  ]);
+  final validator = DeeplyImmutableValidator(
+    index,
+    coreTypes,
+    diagnosticReporter,
+  );
   for (final library in libraries) {
     validator.visitLibrary(library);
   }
@@ -34,10 +43,19 @@ class DeeplyImmutableValidator {
   final DiagnosticReporter diagnosticReporter;
   final Class pragmaClass;
   final Field pragmaName;
+  // Can be null if nativewrappers library is not available.
+  final Class? nativeFieldWrapperClass1Class;
 
-  DeeplyImmutableValidator(this.coreTypes, this.diagnosticReporter)
-    : pragmaClass = coreTypes.pragmaClass,
-      pragmaName = coreTypes.pragmaName;
+  DeeplyImmutableValidator(
+    LibraryIndex index,
+    this.coreTypes,
+    this.diagnosticReporter,
+  ) : pragmaClass = coreTypes.pragmaClass,
+      pragmaName = coreTypes.pragmaName,
+      nativeFieldWrapperClass1Class = index.tryGetClass(
+        'dart:nativewrappers',
+        'NativeFieldWrapperClass1',
+      );
 
   void visitLibrary(Library library) {
     for (final cls in library.classes) {
@@ -49,6 +67,13 @@ class DeeplyImmutableValidator {
     _validateDeeplyImmutable(node);
   }
 
+  bool _isOrExtendsNativeFieldWrapper1Class(Class? node) {
+    while (node != null && node != nativeFieldWrapperClass1Class) {
+      node = node.superclass;
+    }
+    return node != null;
+  }
+
   void _validateDeeplyImmutable(Class node) {
     if (!_isDeeplyImmutableClass(node)) {
       // If class is not marked deeply immutable, check that none of the super
@@ -72,7 +97,9 @@ class DeeplyImmutableValidator {
     }
 
     final superClass = node.superclass;
-    if (superClass != null && superClass != coreTypes.objectClass) {
+    if (superClass != null &&
+        superClass != coreTypes.objectClass &&
+        !_isOrExtendsNativeFieldWrapper1Class(superClass)) {
       if (!_isDeeplyImmutableClass(superClass)) {
         diagnosticReporter.report(
           messageFfiDeeplyImmutableSupertypeMustBeDeeplyImmutable,

runtime/tests/vm/dart/isolates/shared_test_body.dart

@@ -9,34 +9,29 @@ import 'dart:concurrent';
 import 'dart:ffi';
 import 'dart:io';
 import 'dart:isolate';
+import 'dart:typed_data';
 
 import 'package:expect/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:ffi/ffi.dart';
 
-class WorkItem {
-  int i;
+void doWork(int i, SendPort results) {
   int result = 0;
-
-  WorkItem(this.i);
-
-  doWork(SendPort results) {
-    // Calculate fibonacci number i.
-    if (i < 3) {
-      result = 1;
-    } else {
-      int pp = 1;
-      int p = 1;
-      int j = 3;
-      while (j <= i) {
-        result = pp + p;
-        pp = p;
-        p = result;
-        j++;
-      }
+  // Calculate fibonacci number i.
+  if (i < 3) {
+    result = 1;
+  } else {
+    int pp = 1;
+    int p = 1;
+    int j = 3;
+    while (j <= i) {
+      result = pp + p;
+      pp = p;
+      p = result;
+      j++;
     }
-    results.send(<int>[i, result]);
   }
+  results.send(<int>[i, result]);
 }
 
 class SharedState {
@@ -48,7 +43,7 @@ int totalWorkItems = 10000;
 int numberOfWorkers = 8;
 
 @pragma('vm:shared')
-late List<WorkItem> workItems;
+late Uint16List workItems;
 @pragma('vm:shared')
 late int lastProcessed;
 @pragma('vm:shared')
@@ -61,7 +56,9 @@ late var results = <int, int>{};
 void init() {
   SharedState.totalProcessed = 0;
   lastProcessed = 0;
-  workItems = List<WorkItem>.generate(totalWorkItems, (i) => WorkItem(i + 1));
+  workItems = Uint16List.fromList(
+    List<int>.generate(totalWorkItems, (i) => i + 1),
+  );
   mutex = Mutex();
 }
 
@@ -92,7 +89,7 @@ void main(List<String> args) async {
         if (mine >= workItems.length) {
           break;
         }
-        workItems[mine].doWork(sendPort);
+        doWork(workItems[mine], sendPort);
         countProcessed++;
         mutex.runLocked(() => SharedState.totalProcessed++);
         await Future.delayed(Duration(seconds: 0));

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -3284,6 +3284,17 @@ void FieldAccessErrorSlowPath::PushArgumentsForRuntimeCall(
   __ PushObject(Field::ZoneHandle(OriginalField()));
 }
 
+void ThrowIfValueCantBeSharedSlowPath::PushArgumentsForRuntimeCall(
+    FlowGraphCompiler* compiler) {
+  __ PushObject(Field::ZoneHandle(OriginalField()));
+  __ PushRegister(value());
+}
+
+void ThrowIfValueCantBeSharedSlowPath::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
+  ThrowErrorSlowPathCode::EmitNativeCode(compiler);
+}
+
 void FlowGraphCompiler::EmitNativeMove(
     const compiler::ffi::NativeLocation& destination,
     const compiler::ffi::NativeLocation& source,

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -356,6 +356,35 @@ class FieldAccessErrorSlowPath : public ThrowErrorSlowPathCode {
   }
 };
 
+class ThrowIfValueCantBeSharedSlowPath : public ThrowErrorSlowPathCode {
+ public:
+  explicit ThrowIfValueCantBeSharedSlowPath(Instruction* instruction,
+                                            Register value)
+      : ThrowErrorSlowPathCode(instruction,
+                               kThrowIfValueCantBeSharedRuntimeEntry),
+        value_(value) {
+    ASSERT(instruction->IsStoreStaticField());
+  }
+  virtual const char* name() { return "shared value error"; }
+
+  virtual intptr_t GetNumberOfArgumentsForRuntimeCall() {
+    return 2;  // field, value
+  }
+
+  virtual void PushArgumentsForRuntimeCall(FlowGraphCompiler* compiler);
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+ private:
+  Register value_;
+
+  FieldPtr OriginalField() const {
+    return instruction()->AsStoreStaticField()->field().Original();
+  }
+
+  Register value() const { return value_; }
+};
+
 class FlowGraphCompiler : public ValueObject {
  private:
   class BlockInfo : public ZoneAllocated {

runtime/vm/compiler/backend/il_arm.cc

@@ -2901,8 +2901,7 @@ LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
-  const bool can_call_to_throw =
-      FLAG_experimental_shared_data && !field().is_shared();
+  const bool can_call_to_throw = FLAG_experimental_shared_data;
   LocationSummary* locs = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps,
                       can_call_to_throw ? LocationSummary::kCallOnSlowPath
@@ -2918,12 +2917,37 @@ void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 
   compiler->used_static_fields().Add(&field());
 
-  if (FLAG_experimental_shared_data && !field().is_shared()) {
-    ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
-    compiler->AddSlowPathCode(slow_path);
+  if (FLAG_experimental_shared_data) {
+    if (!field().is_shared()) {
+      ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
+      compiler->AddSlowPathCode(slow_path);
 
-    __ LoadIsolate(temp);
-    __ BranchIfZero(temp, slow_path->entry_label());
+      __ LoadIsolate(temp);
+      __ BranchIfZero(temp, slow_path->entry_label());
+    } else {
+      // TODO(dartbug.com/61078): use field static type information to decide
+      // whether the following value check is needed or not.
+      auto throw_if_cant_be_shared_slow_path =
+          new ThrowIfValueCantBeSharedSlowPath(this, value);
+      compiler->AddSlowPathCode(throw_if_cant_be_shared_slow_path);
+
+      compiler::Label allow_store;
+      __ BranchIfSmi(value, &allow_store, compiler::Assembler::kNearJump);
+      __ ldrb(temp, compiler::FieldAddress(
+                        value, compiler::target::Object::tags_offset()));
+      __ TestImmediate(temp,
+                       1 << compiler::target::UntaggedObject::kImmutableBit);
+      __ b(&allow_store, NOT_ZERO);
+
+      // Allow TypedData because they contain non-structural mutable state.
+      __ LoadClassId(temp, value);
+      __ CompareImmediate(temp, kFirstTypedDataCid);
+      __ b(throw_if_cant_be_shared_slow_path->entry_label(), LT);
+      __ CompareImmediate(temp, kLastTypedDataCid);
+      __ b(throw_if_cant_be_shared_slow_path->entry_label(), GT);
+
+      __ Bind(&allow_store);
+    }
   }
 
   __ LoadFromOffset(

runtime/vm/compiler/backend/il_arm64.cc

@@ -2467,8 +2467,7 @@ LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
-  const bool can_call_to_throw =
-      FLAG_experimental_shared_data && !field().is_shared();
+  const bool can_call_to_throw = FLAG_experimental_shared_data;
   LocationSummary* locs = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps,
                       can_call_to_throw ? LocationSummary::kCallOnSlowPath
@@ -2484,12 +2483,38 @@ void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 
   compiler->used_static_fields().Add(&field());
 
-  if (FLAG_experimental_shared_data && !field().is_shared()) {
-    ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
-    compiler->AddSlowPathCode(slow_path);
+  if (FLAG_experimental_shared_data) {
+    if (!field().is_shared()) {
+      auto slow_path = new FieldAccessErrorSlowPath(this);
+      compiler->AddSlowPathCode(slow_path);
 
-    __ LoadIsolate(temp);
-    __ BranchIfZero(temp, slow_path->entry_label());
+      __ LoadIsolate(temp);
+      __ BranchIfZero(temp, slow_path->entry_label());
+    } else {
+      // TODO(dartbug.com/61078): use field static type information to decide
+      // whether the following value check is needed or not.
+      auto throw_if_cant_be_shared_slow_path =
+          new ThrowIfValueCantBeSharedSlowPath(this, value);
+      compiler->AddSlowPathCode(throw_if_cant_be_shared_slow_path);
+
+      compiler::Label allow_store;
+      __ BranchIfSmi(value, &allow_store, compiler::Assembler::kNearJump);
+      __ ldr(temp,
+             compiler::FieldAddress(value,
+                                    compiler::target::Object::tags_offset()),
+             compiler::kUnsignedByte);
+      __ tbnz(&allow_store, temp,
+              compiler::target::UntaggedObject::kImmutableBit);
+
+      // Allow TypedData because they contain non-structural mutable state.
+      __ LoadClassId(temp, value);
+      __ CompareImmediate(temp, kFirstTypedDataCid);
+      __ b(throw_if_cant_be_shared_slow_path->entry_label(), UNSIGNED_LESS);
+      __ CompareImmediate(temp, kLastTypedDataCid);
+      __ b(throw_if_cant_be_shared_slow_path->entry_label(), UNSIGNED_GREATER);
+
+      __ Bind(&allow_store);
+    }
   }
 
   __ LoadFromOffset(

runtime/vm/compiler/backend/il_ia32.cc

@@ -2104,8 +2104,7 @@ void GuardFieldLengthInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
-  const bool can_call_to_throw =
-      FLAG_experimental_shared_data && !field().is_shared();
+  const bool can_call_to_throw = FLAG_experimental_shared_data;
   LocationSummary* locs = new (zone)
       LocationSummary(zone, 1, 1,
                       can_call_to_throw ? LocationSummary::kCallOnSlowPath
@@ -2122,18 +2121,44 @@ void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 
   compiler->used_static_fields().Add(&field());
 
-  if (FLAG_experimental_shared_data && !field().is_shared()) {
-    ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
+  if (FLAG_experimental_shared_data) {
     if (value()->NeedsWriteBarrier()) {
       // Value input is a writable register and should be manually preserved
       // across allocation slow-path.  Add it to live_registers set which
       // determines which registers to preserve.
       locs()->live_registers()->Add(Location::RegisterLocation(in));
     }
-    compiler->AddSlowPathCode(slow_path);
+    if (!field().is_shared()) {
+      ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
+      compiler->AddSlowPathCode(slow_path);
 
-    __ LoadIsolate(temp);
-    __ BranchIfZero(temp, slow_path->entry_label());
+      __ LoadIsolate(temp);
+      __ BranchIfZero(temp, slow_path->entry_label());
+    } else {
+      // TODO(dartbug.com/61078): use field static type information to decide
+      // whether the following value check is needed or not.
+      auto throw_if_cant_be_shared_slow_path =
+          new ThrowIfValueCantBeSharedSlowPath(this, in);
+      compiler->AddSlowPathCode(throw_if_cant_be_shared_slow_path);
+
+      compiler::Label allow_store;
+      __ BranchIfSmi(in, &allow_store, compiler::Assembler::kNearJump);
+
+      __ movl(temp, compiler::FieldAddress(
+                        in, compiler::target::Object::tags_offset()));
+      __ testl(temp, compiler::Immediate(
+                         1 << compiler::target::UntaggedObject::kImmutableBit));
+      __ j(NOT_ZERO, &allow_store);
+
+      // Allow TypedData because they contain non-structural mutable state.
+      __ LoadClassId(temp, in);
+      __ CompareImmediate(temp, kFirstTypedDataCid);
+      __ BranchIf(LESS, throw_if_cant_be_shared_slow_path->entry_label());
+      __ CompareImmediate(temp, kLastTypedDataCid);
+      __ BranchIf(GREATER, throw_if_cant_be_shared_slow_path->entry_label());
+
+      __ Bind(&allow_store);
+    }
   }
 
   __ movl(temp,