AOT: Reassign class ids so class hierarchies have contiguous ranges.

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 521 matching lines @@
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
   intptr_t GetClassId() const {
     uword tags = ptr()->tags_;
     return ClassIdTag::decode(tags);
   }
 
+  void SetClassId(intptr_t new_cid) {
+    uword tags = ptr()->tags_;
+    ptr()->tags_ = ClassIdTag::update(new_cid, tags);
+  }
+
   template<class TagBitField>
   void UpdateTagBit(bool value) {
     uword tags = ptr()->tags_;
     uword old_tags;
     do {
       old_tags = tags;
       uword new_tags = TagBitField::update(value, old_tags);
       tags = AtomicOperations::CompareAndSwapWord(
           &ptr()->tags_, old_tags, new_tags);
     } while (tags != old_tags);
@@ skipping 37 matching lines @@
     *const_cast<RawSmi**>(addr) = value;
   }
 
   friend class Api;
   friend class ApiMessageReader;  // GetClassId
   friend class Serializer;  // GetClassId
   friend class Array;
   friend class Become;  // GetClassId
   friend class Bigint;
   friend class ByteBuffer;
+  friend class CidRewriteVisitor;
   friend class Closure;
   friend class Code;
   friend class Double;
   friend class ForwardPointersVisitor;  // StorePointer
   friend class FreeListElement;
   friend class Function;
   friend class GCMarker;
   friend class ExternalTypedData;
   friend class ForwardList;
   friend class GrowableObjectArray;  // StorePointer
@@ skipping 103 matching lines @@
   uint16_t num_native_fields_;  // Number of native fields in class.
   uint16_t state_bits_;
 
   friend class Instance;
   friend class Isolate;
   friend class Object;
   friend class RawInstance;
   friend class RawInstructions;
   friend class SnapshotReader;
   friend class InstanceSerializationCluster;
+  friend class CidRewriteVisitor;
 };
 
 
 class RawUnresolvedClass : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_prefix_);
   }
   RawLibraryPrefix* library_prefix_;  // Library prefix qualifier for the ident.
@@ skipping 208 matching lines @@
   TokenPosition token_pos_;
   classid_t guarded_cid_;
   classid_t is_nullable_;  // kNullCid if field can contain null value and
                            // any other value otherwise.
   // Offset to the guarded length field inside an instance of class matching
   // guarded_cid_. Stored corrected by -kHeapObjectTag to simplify code
   // generated on platforms with weak addressing modes (ARM, MIPS).
   int8_t guarded_list_length_in_object_offset_;
 
   uint8_t kind_bits_;  // static, final, const, has initializer....
+
+  friend class CidRewriteVisitor;
 };
 
 
 class RawLiteralToken : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LiteralToken);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->literal_);
   }
   RawString* literal_;  // Literal characters as they appear in source text.
@@ skipping 714 matching lines @@
   // can describe the issue without needing the signature.
   union {
     RawFunction* signature_;  // If not null, this type is a function type.
     RawLanguageError* error_;  // If not null, type is malformed or malbounded.
   } sig_or_err_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->sig_or_err_.error_);
   }
   TokenPosition token_pos_;
   int8_t type_state_;
+
+  friend class CidRewriteVisitor;
 };
 
 
 class RawTypeRef : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeRef);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
@@ skipping 12 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->name_);
   }
   RawString* name_;
   RawSmi* hash_;
   RawAbstractType* bound_;  // ObjectType if no explicit bound specified.
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->bound_); }
   classid_t parameterized_class_id_;
   TokenPosition token_pos_;
   int16_t index_;
   int8_t type_state_;
+
+  friend class CidRewriteVisitor;
 };
 
 
 class RawBoundedType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(BoundedType);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_);
   }
@@ skipping 699 matching lines @@
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_