Implement instance field guards for kernel-based FlowGraphBuilder

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 2350 matching lines @@
 Fragment FlowGraphBuilder::StoreInstanceField(const dart::Field& field) {
   Value* value = Pop();
   // TODO(27590): Omit store barrier when possible (e.g., storing
   // some constants).
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       field, Pop(), value, kEmitStoreBarrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
+Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(const dart::Field& field) {
+  Fragment instructions;
+  if (FLAG_use_field_guards) {
+    LocalVariable* store_expression = MakeTemporary();
+    instructions += LoadLocal(store_expression);
+    instructions += GuardFieldClass(field, Thread::Current()->GetNextDeoptId());
+    instructions += LoadLocal(store_expression);
+    instructions +=
+        GuardFieldLength(field, Thread::Current()->GetNextDeoptId());
+  }
+  instructions += StoreInstanceField(field);
+  return instructions;
+}
+
+
 Fragment FlowGraphBuilder::StoreInstanceField(intptr_t offset) {
   Value* value = Pop();
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, Pop(), value, kEmitStoreBarrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreLocal(LocalVariable* variable) {
   Fragment instructions;
@@ skipping 711 matching lines @@
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
-  // TODO(27590): Add support for FLAG_use_field_guards.
   Fragment body(normal_entry);
   if (is_setter) {
     if (is_method) {
       body += LoadLocal(scopes_->this_variable);
       body += LoadLocal(setter_value);
-      body += StoreInstanceField(field);
+      body += StoreInstanceFieldGuarded(field);
     } else {
       body += LoadLocal(setter_value);
       body += StoreStaticField(field);
     }
     body += NullConstant();
   } else if (is_method) {
     body += LoadLocal(scopes_->this_variable);
     body += LoadField(field);
   } else if (field.is_const()) {
     // If the parser needs to know the value of an uninitialized constant field
@@ skipping 67 matching lines @@
   // The context is on top of the operand stack.  Store `this`.  The context
   // doesn't need a parent pointer because it doesn't close over anything
   // else.
   fragment += LoadLocal(scopes_->this_variable);
   fragment += StoreInstanceField(Context::variable_offset(0));
 
   return fragment;
 }
 
 
+Fragment FlowGraphBuilder::GuardFieldLength(const dart::Field& field,
+                                            intptr_t deopt_id) {
+  return Fragment(new (Z) GuardFieldLengthInstr(Pop(), field, deopt_id));
+}
+
+
+Fragment FlowGraphBuilder::GuardFieldClass(const dart::Field& field,
+                                           intptr_t deopt_id) {
+  return Fragment(new (Z) GuardFieldClassInstr(Pop(), field, deopt_id));
+}
+
+
 FlowGraph* FlowGraphBuilder::BuildGraphOfMethodExtractor(
     const Function& method) {
   // A method extractor is the implicit getter for a method.
   const Function& function =
       Function::ZoneHandle(Z, method.extracted_method_closure());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
   Fragment body(normal_entry);
@@ skipping 302 matching lines @@
   //     var x = (expr);
   //   }
   for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
     Field* kernel_field = kernel_klass->fields()[i];
     Expression* init = kernel_field->initializer();
     if (!kernel_field->IsStatic() && init != NULL) {
       dart::Field& field =
           dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
 
       EnterScope(kernel_field);
-      // TODO(27590): Support FLAG_use_field_guards.
       instructions += LoadLocal(scopes_->this_variable);
       instructions += TranslateExpression(init);
-      instructions += StoreInstanceField(field);
+      instructions += StoreInstanceFieldGuarded(field);
       ExitScope(kernel_field);
     }
   }
 
   // These to come from:
   //   class A {
   //     var x;
   //     var y;
   //     A(this.x) : super(expr), y = (expr);
   //   }
   for (intptr_t i = 0; i < initializers->length(); i++) {
     Initializer* initializer = (*initializers)[i];
     if (initializer->IsFieldInitializer()) {
       FieldInitializer* init = FieldInitializer::Cast(initializer);
       dart::Field& field =
           dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(init->field()));
 
-      // TODO(27590): Support FLAG_use_field_guards.
       instructions += LoadLocal(scopes_->this_variable);
       instructions += TranslateExpression(init->value());
-      instructions += StoreInstanceField(field);
+      instructions += StoreInstanceFieldGuarded(field);
     } else if (initializer->IsSuperInitializer()) {
       SuperInitializer* init = SuperInitializer::Cast(initializer);
 
       instructions += LoadLocal(scopes_->this_variable);
       instructions += PushArgument();
 
       ASSERT(init->arguments()->types().length() == 0);
       Array& argument_names = Array::ZoneHandle(Z);
       instructions += TranslateArguments(init->arguments(), &argument_names);
 
@@ skipping 2025 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart