Initial support for length guards on final fields.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1969 matching lines @@
   // to have or kDynamicCid if such class id is not known.
   // Stores to this field must update this information hence the name.
   intptr_t guarded_cid() const { return raw_ptr()->guarded_cid_; }
 
   void set_guarded_cid(intptr_t cid) const {
     raw_ptr()->guarded_cid_ = cid;
   }
   static intptr_t guarded_cid_offset() {
     return OFFSET_OF(RawField, guarded_cid_);
   }
+  // Return the list length that any list stored in this field is guaranteed
+  // to have. If length is kUnknownFixedLength the length has not
+  // been determined. If length is kNoFixedLength this field has multiple
+  // list lengths associated with it and cannot be predicted.
+  intptr_t guarded_list_length() const {
+    return raw_ptr()->guarded_list_length_;
+  }
+  void set_guarded_list_length(intptr_t list_length) const {
+    raw_ptr()->guarded_list_length_ = list_length;
+  }
+  static intptr_t guarded_list_length_offset() {
+    return OFFSET_OF(RawField, guarded_list_length_);
+  }
+  bool needs_length_check() const {
+    const bool r = guarded_list_length() >= Field::kUnknownFixedLength;
+    ASSERT(!r || is_final());
+    return r;
+  }
 
   static bool IsExternalizableCid(intptr_t cid) {
     return (cid == kOneByteStringCid) || (cid == kTwoByteStringCid);
   }
 
+  enum {
+    kUnknownFixedLength = -1,
+    kNoFixedLength = -2,
+  };
   // Returns false if any value read from this field is guaranteed to be
   // not null.
   // Internally we is_nullable_ field contains either kNullCid (nullable) or
   // any other value (non-nullable) instead of boolean. This is done to simplify
   // guarding sequence in the generated code.
   bool is_nullable() const {
     return raw_ptr()->is_nullable_ == kNullCid;
   }
   void set_is_nullable(bool val) const {
     raw_ptr()->is_nullable_ = val ? kNullCid : kIllegalCid;
   }
   static intptr_t is_nullable_offset() {
     return OFFSET_OF(RawField, is_nullable_);
   }
 
   // Update guarded class id and nullability of the field to reflect assignment
-  // of the value with the given class id to this field.
+  // of the value with the given class id to this field. May trigger
+  // deoptimization of dependent code.
   void UpdateCid(intptr_t cid) const;
+  // Update guarded class length of the field to reflect assignment of the
+  // value with the given length. May trigger deoptimization of dependent code.
+  void UpdateLength(intptr_t length) const;
 
   // Return the list of optimized code objects that were optimized under
   // assumptions about guarded class id and nullability of this field.
   // These code objects must be deoptimized when field's properties change.
   // Code objects are held weakly via an indirection through WeakProperty.
   RawArray* dependent_code() const;
   void set_dependent_code(const Array& array) const;
 
   // Add the given code object to the list of dependent ones.
   void RegisterDependentCode(const Code& code) const;
@@ skipping 4056 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_