[vm/shared] Throw AccessError when isolategroup mutator accesses static fields.

Sample snapshot size comparison before/after:

===
dart2js_aot.dart.snapshot before: 19946368
                          after:  19998800  (with flag turned on)
                          delta:     52432 0.26%
===

Bug: #54530
Bug: #56841
CoreLibraryReviewExempt: internal library change only
Change-Id: I34b1945c040bbad22cb3ec6fdb6e6776df31a82f
TEST=run_isolate_group_run_test.dart
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/422360
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Alexander Aprelev <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: aam

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -3273,6 +3273,11 @@ void LateInitializationErrorSlowPath::EmitSharedStubCall(
 #endif
 }
 
+void FieldAccessErrorSlowPath::PushArgumentsForRuntimeCall(
+    FlowGraphCompiler* compiler) {
+  __ PushObject(Field::ZoneHandle(OriginalField()));
+}
+
 void FlowGraphCompiler::EmitNativeMove(
     const compiler::ffi::NativeLocation& destination,
     const compiler::ffi::NativeLocation& source,

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -334,6 +334,28 @@ class LateInitializationErrorSlowPath : public ThrowErrorSlowPathCode {
   }
 };
 
+class FieldAccessErrorSlowPath : public ThrowErrorSlowPathCode {
+ public:
+  explicit FieldAccessErrorSlowPath(Instruction* instruction)
+      : ThrowErrorSlowPathCode(
+            instruction,
+            kStaticFieldAccessedWithoutIsolateErrorRuntimeEntry) {
+    ASSERT(instruction->IsStoreStaticField());
+  }
+  virtual const char* name() { return "field access error"; }
+
+  virtual intptr_t GetNumberOfArgumentsForRuntimeCall() {
+    return 1;  // field
+  }
+
+  virtual void PushArgumentsForRuntimeCall(FlowGraphCompiler* compiler);
+
+ private:
+  FieldPtr OriginalField() const {
+    return instruction()->AsStoreStaticField()->field().Original();
+  }
+};
+
 class FlowGraphCompiler : public ValueObject {
  private:
   class BlockInfo : public ZoneAllocated {

runtime/vm/compiler/backend/il.cc

@@ -4553,8 +4553,8 @@ void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
       __ BranchIf(EQUAL, slow_path->entry_label());
       return;
     }
-    ASSERT(field().has_initializer());
-    ASSERT(field().is_late());
+    ASSERT((FLAG_experimental_shared_data && !field().is_shared()) ||
+           (field().has_initializer() && field().is_late()));
     auto object_store = compiler->isolate_group()->object_store();
     const Field& original_field = Field::ZoneHandle(field().Original());
 
@@ -4568,7 +4568,9 @@ void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
     } else {
       // The stubs below call the initializer function directly, so make sure
       // one is created.
-      original_field.EnsureInitializerFunction();
+      if (original_field.has_nontrivial_initializer()) {
+        original_field.EnsureInitializerFunction();
+      }
       stub =
           field().is_shared()
               ? (field().is_final()

runtime/vm/compiler/backend/il.h

@@ -6710,12 +6710,13 @@ class LoadStaticFieldInstr : public TemplateLoadField<0> {
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
-class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
+class StoreStaticFieldInstr : public TemplateDefinition<1, Throws> {
  public:
   StoreStaticFieldInstr(const Field& field,
                         Value* value,
-                        const InstructionSource& source)
-      : TemplateDefinition(source),
+                        const InstructionSource& source,
+                        intptr_t deopt_id)
+      : TemplateDefinition(source, deopt_id),
         field_(field),
         token_pos_(source.token_pos) {
     DEBUG_ASSERT(field.IsNotTemporaryScopedHandle());
@@ -6731,6 +6732,9 @@ class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimizeAfterCall() const {
+    return FLAG_experimental_shared_data;
+  }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
@@ -6739,6 +6743,9 @@ class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
 
   virtual bool MayHaveVisibleEffect() const { return true; }
 
+  virtual bool CanTriggerGC() const { return FLAG_experimental_shared_data; }
+  virtual bool MayThrow() const { return FLAG_experimental_shared_data; }
+
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT

runtime/vm/compiler/backend/il_arm.cc

@@ -2901,8 +2901,12 @@ 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();
   LocationSummary* locs = new (zone)
-      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+      LocationSummary(zone, kNumInputs, kNumTemps,
+                      can_call_to_throw ? LocationSummary::kCallOnSlowPath
+                                        : LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
@@ -2914,6 +2918,14 @@ 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);
+
+    __ LoadIsolate(temp);
+    __ BranchIfZero(temp, slow_path->entry_label());
+  }
+
   __ LoadFromOffset(
       temp, THR,
       field().is_shared()

runtime/vm/compiler/backend/il_arm64.cc

@@ -2465,8 +2465,12 @@ 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();
   LocationSummary* locs = new (zone)
-      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+      LocationSummary(zone, kNumInputs, kNumTemps,
+                      can_call_to_throw ? LocationSummary::kCallOnSlowPath
+                                        : LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
@@ -2478,6 +2482,14 @@ 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);
+
+    __ LoadIsolate(temp);
+    __ BranchIfZero(temp, slow_path->entry_label());
+  }
+
   __ LoadFromOffset(
       temp, THR,
       field().is_shared()

runtime/vm/compiler/backend/il_ia32.cc

@@ -2104,20 +2104,38 @@ void GuardFieldLengthInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
-  LocationSummary* locs =
-      new (zone) LocationSummary(zone, 1, 1, LocationSummary::kNoCall);
+  const bool can_call_to_throw =
+      FLAG_experimental_shared_data && !field().is_shared();
+  LocationSummary* locs = new (zone)
+      LocationSummary(zone, 1, 1,
+                      can_call_to_throw ? LocationSummary::kCallOnSlowPath
+                                        : LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsWriteBarrier() ? Location::WritableRegister()
                                                : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register value = locs()->in(0).reg();
+  Register in = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
   compiler->used_static_fields().Add(&field());
 
+  if (FLAG_experimental_shared_data && !field().is_shared()) {
+    ThrowErrorSlowPathCode* slow_path = new FieldAccessErrorSlowPath(this);
+    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);
+
+    __ LoadIsolate(temp);
+    __ BranchIfZero(temp, slow_path->entry_label());
+  }
+
   __ movl(temp,
           compiler::Address(
               THR,
@@ -2127,7 +2145,7 @@ void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Note: static fields ids won't be changed by hot-reload.
   __ movl(
       compiler::Address(temp, compiler::target::FieldTable::OffsetOf(field())),
-      value);
+      in);
 }
 
 LocationSummary* InstanceOfInstr::MakeLocationSummary(Zone* zone,

runtime/vm/compiler/backend/il_riscv.cc

@@ -2664,8 +2664,12 @@ LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
+  const bool can_call_to_throw =
+      FLAG_experimental_shared_data && !field().is_shared();
   LocationSummary* locs = new (zone)
-      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+      LocationSummary(zone, kNumInputs, kNumTemps,
+                      can_call_to_throw ? LocationSummary::kCallOnSlowPath
+                                        : LocationSummary::kNoCall);
   locs->set_in(0, Location::RequiresRegister());
   return locs;
 }
@@ -2675,6 +2679,14 @@ 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);
+
+    __ LoadIsolate(TMP);
+    __ BranchIfZero(TMP, slow_path->entry_label());
+  }
+
   __ LoadFromOffset(
       TMP, THR,
       field().is_shared()

runtime/vm/compiler/backend/il_x64.cc

@@ -2442,8 +2442,12 @@ 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();
   LocationSummary* locs = new (zone)
-      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+      LocationSummary(zone, kNumInputs, kNumTemps,
+                      can_call_to_throw ? LocationSummary::kCallOnSlowPath
+                                        : LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterLocation(kWriteBarrierValueReg));
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
@@ -2455,6 +2459,14 @@ 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);
+
+    __ LoadIsolate(temp);
+    __ BranchIfZero(temp, slow_path->entry_label());
+  }
+
   __ movq(temp,
           compiler::Address(
               THR,

runtime/vm/compiler/frontend/base_flow_graph_builder.cc

@@ -634,9 +634,14 @@ Fragment BaseFlowGraphBuilder::StoreFieldGuarded(
 
 Fragment BaseFlowGraphBuilder::LoadStaticField(const Field& field,
                                                bool calls_initializer) {
+  // "Inititalizer" code is in charge of checking non-shared field access from
+  // stateless isolates(which exist when experimental_shared_data is enabled).
+  const bool do_call_initializer =
+      calls_initializer ||
+      (dart::FLAG_experimental_shared_data && !field.is_shared());
   LoadStaticFieldInstr* load = new (Z) LoadStaticFieldInstr(
-      field, InstructionSource(), calls_initializer,
-      calls_initializer ? GetNextDeoptId() : DeoptId::kNone);
+      field, InstructionSource(), do_call_initializer,
+      do_call_initializer ? GetNextDeoptId() : DeoptId::kNone);
   Push(load);
   return Fragment(load);
 }
@@ -674,7 +679,8 @@ Fragment BaseFlowGraphBuilder::Utf8Scan() {
 Fragment BaseFlowGraphBuilder::StoreStaticField(TokenPosition position,
                                                 const Field& field) {
   return Fragment(new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(),
-                                                InstructionSource(position)));
+                                                InstructionSource(position),
+                                                GetNextDeoptId()));
 }
 
 Fragment BaseFlowGraphBuilder::StoreIndexed(classid_t class_id) {