VM [KERNEL] Elide null-initialization of the fields

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 4055 matching lines @@
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
   return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
+Fragment FlowGraphBuilder::TranslateFieldInitializer(Field* kernel_field,
+                                                     Expression* init) {
+  dart::Field& field =
+      dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+  Fragment instructions;
+  bool elide_initialization = false;
+  instructions += LoadLocal(scopes_->this_variable);
+  Fragment initializer = TranslateExpression(init);

[Vyacheslav Egorov (Google), 2017/03/31 15:00:56]

Better init->IsNullLiteral() instead of this.

+  instructions += initializer;
+  // Elide initialization if the expression is null.
+  if (initializer.entry->IsConstant() &&
+      initializer.entry == initializer.current) {
+    ConstantInstr* inst = initializer.entry->AsConstant();
+    if (inst->value().IsNull()) {
+      elide_initialization = true;
+    }
+  }
+  instructions += StoreInstanceFieldGuarded(field, true);
+  if (elide_initialization) {
+    field.RecordStore(Object::null_object());
+    return Fragment();
+  } else {
+    return instructions;
+  }
+}
+
+
 Fragment FlowGraphBuilder::TranslateInitializers(
     Class* kernel_klass,
     List<Initializer>* initializers) {
   Fragment instructions;
 
   // These come from:
   //   class A {
   //     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);
-      instructions += LoadLocal(scopes_->this_variable);
-      instructions += TranslateExpression(init);
-      instructions += StoreInstanceFieldGuarded(field, true);
+      instructions += TranslateFieldInitializer(kernel_field, init);
       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()));
-
-      instructions += LoadLocal(scopes_->this_variable);
-      instructions += TranslateExpression(init->value());
-      instructions += StoreInstanceFieldGuarded(field, true);
+      instructions += TranslateFieldInitializer(init->field(), init->value());
     } 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 2337 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)