Initial support for length guards on final fields.

runtime/vm/object.cc

 // Copyright (c) 2012, 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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 41 matching lines @@
 DEFINE_FLAG(int, huge_method_cutoff_in_tokens, 20000,
     "Huge method cutoff in tokens: Disables optimizations for huge methods.");
 DEFINE_FLAG(int, huge_method_cutoff_in_code_size, 200000,
     "Huge method cutoff in unoptimized code size (in bytes).");
 DEFINE_FLAG(bool, throw_on_javascript_int_overflow, false,
     "Throw an exception when the result of an integer calculation will not "
     "fit into a javascript integer.");
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
+DECLARE_FLAG(bool, trace_deoptimization);
+DECLARE_FLAG(bool, trace_deoptimization_verbose);
 DECLARE_FLAG(bool, error_on_bad_override);
 
 static const char* kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 cpp_vtable Object::handle_vtable_ = 0;
 cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
@@ skipping 5225 matching lines @@
   } else {
     result.SetOffset(0);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   result.set_guarded_cid(kIllegalCid);
   result.set_is_nullable(false);
+  result.set_guarded_list_length(Field::kUnknownFixedLength);
   result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
 
 
 RawField* Field::Clone(const Class& new_owner) const {
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->owner());
@@ skipping 103 matching lines @@
   set_dependent_code(Object::null_array());
 
   // Deoptimize all dependent code on the stack.
   Code& code = Code::Handle();
   {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     while (frame != NULL) {
       code = frame->LookupDartCode();
       if (IsDependentCode(code_objects, code)) {
+        if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
+          Function& function = Function::Handle(code.function());
+          OS::PrintErr("Deoptimizing %s because guard on field %s failed.\n",
+              function.ToFullyQualifiedCString(),
+              ToCString());
+        }
         DeoptimizeAt(code, frame->pc());
       }
       frame = iterator.NextFrame();
     }
   }
 
   // Switch functions that use dependent code to unoptimized code.
   WeakProperty& weak_property = WeakProperty::Handle();
   Function& function = Function::Handle();
   for (intptr_t i = 0; i < code_objects.Length(); i++) {
     weak_property ^= code_objects.At(i);
     code ^= weak_property.key();
     if (code.IsNull()) {
       // Code was garbage collected already.
       continue;
     }
 
     function ^= code.function();
     // If function uses dependent code switch it to unoptimized.
     if (function.CurrentCode() == code.raw()) {
       ASSERT(function.HasOptimizedCode());
+      if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
+        OS::PrintErr("Switching %s to unoptimized code because guard"
+                     " on field %s was violated.\n",
+                     function.ToFullyQualifiedCString(),
+                     ToCString());
+      }
       function.SwitchToUnoptimizedCode();
     }
   }
 }
 
 
 void Field::UpdateCid(intptr_t cid) const {
   if (guarded_cid() == kIllegalCid) {
     // Field is assigned first time.
     set_guarded_cid(cid);
@@ skipping 19 matching lines @@
     ASSERT(guarded_cid() != cid);
     set_guarded_cid(kDynamicCid);
     set_is_nullable(true);
   }
 
   // Expected class id or nullability of the field changed.
   DeoptimizeDependentCode();
 }
 
 
+void Field::UpdateLength(intptr_t list_length) const {
+  ASSERT(is_final() || (!is_final() &&
+                        (list_length < Field::kUnknownFixedLength)));
+  ASSERT((list_length == Field::kNoFixedLength) ||
+         (list_length > Field::kUnknownFixedLength));
+  ASSERT(guarded_cid() != kIllegalCid);
+
+  const bool force_invalidate = (guarded_cid() == kDynamicCid) &&
+                                (list_length != Field::kNoFixedLength);
+
+  const bool list_length_unknown =
+      (guarded_list_length() == Field::kUnknownFixedLength);
+  const bool list_length_changed = (guarded_list_length() != list_length);
+
+  if (list_length_unknown && list_length_changed && !force_invalidate) {
+    // List length set for first time.
+    set_guarded_list_length(list_length);
+    return;
+  }
+
+  if (!list_length_changed && !force_invalidate) {
+    // List length unchanged.
+    return;
+  }
+
+  // Multiple list lengths assigned here, stop tracking length.
+  set_guarded_list_length(Field::kNoFixedLength);
+  DeoptimizeDependentCode();
+}
+
+
 void LiteralToken::set_literal(const String& literal) const {
   StorePointer(&raw_ptr()->literal_, literal.raw());
 }
 
 
 void LiteralToken::set_value(const Object& value) const {
   StorePointer(&raw_ptr()->value_, value.raw());
 }
 
 
@@ skipping 9163 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart