Inline instance object hash code into object header on 64 bit.

runtime/vm/raw_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/raw_object.h"
 
 #include "vm/become.h"
 #include "vm/class_table.h"
 #include "vm/dart.h"
 #include "vm/freelist.h"
@@ skipping 12 matching lines @@
   }
   // All Smi values are valid.
   if (!IsHeapObject()) {
     return;
   }
   // Slightly more readable than a segfault.
   if (this == reinterpret_cast<RawObject*>(kHeapObjectTag)) {
     FATAL("RAW_NULL encountered");
   }
   // Validate that the tags_ field is sensible.
-  uword tags = ptr()->tags_;
+  uint32_t tags = ptr()->tags_;
   intptr_t reserved = ReservedBits::decode(tags);
   if (reserved != 0) {
-    FATAL1("Invalid tags field encountered %#" Px "\n", tags);
+    FATAL1("Invalid tags field encountered %x\n", tags);
   }
   intptr_t class_id = ClassIdTag::decode(tags);
   if (!isolate->class_table()->IsValidIndex(class_id)) {
     FATAL1("Invalid class id encountered %" Pd "\n", class_id);
   }
   if ((class_id == kNullCid) &&
       (isolate->class_table()->At(class_id) == NULL)) {
     // Null class not yet initialized; skip.
     return;
   }
@@ skipping 131 matching lines @@
       break;
     }
     default: {
       // Get the (constant) instance size out of the class object.
       // TODO(koda): Add Size(ClassTable*) interface to allow caching in loops.
       Isolate* isolate = Isolate::Current();
 #if defined(DEBUG)
       ClassTable* class_table = isolate->class_table();
       if (!class_table->IsValidIndex(class_id) ||
           !class_table->HasValidClassAt(class_id)) {
-        FATAL2("Invalid class id: %" Pd " from tags %" Px "\n", class_id,
+        FATAL2("Invalid class id: %" Pd " from tags %x\n", class_id,
                ptr()->tags_);
       }
 #endif  // DEBUG
       RawClass* raw_class = isolate->GetClassForHeapWalkAt(class_id);
       instance_size = raw_class->ptr()->instance_size_in_words_
                       << kWordSizeLog2;
     }
   }
   ASSERT(instance_size != 0);
 #if defined(DEBUG)
-  uword tags = ptr()->tags_;
+  uint32_t tags = ptr()->tags_;
   intptr_t tags_size = SizeTag::decode(tags);
   if ((class_id == kArrayCid) && (instance_size > tags_size && tags_size > 0)) {
     // TODO(22501): Array::MakeArray could be in the process of shrinking
     // the array (see comment therein), having already updated the tags but not
     // yet set the new length. Wait a millisecond and try again.
     int retries_remaining = 1000;  // ... but not forever.
     do {
       OS::Sleep(1);
       const RawArray* raw_array = reinterpret_cast<const RawArray*>(this);
       intptr_t array_length = Smi::Value(raw_array->ptr()->length_);
       instance_size = Array::InstanceSize(array_length);
     } while ((instance_size > tags_size) && (--retries_remaining > 0));
   }
   if ((instance_size != tags_size) && (tags_size != 0)) {
-    FATAL3("Size mismatch: %" Pd " from class vs %" Pd " from tags %" Px "\n",
+    FATAL3("Size mismatch: %" Pd " from class vs %" Pd " from tags %x\n",
            instance_size, tags_size, tags);
   }
 #endif  // DEBUG
   return instance_size;
 }
 
 
 intptr_t RawObject::VisitPointers(ObjectPointerVisitor* visitor) {
   intptr_t size = 0;
 
@@ skipping 297 matching lines @@
 
 
 intptr_t RawNamespace::VisitNamespacePointers(RawNamespace* raw_obj,
                                               ObjectPointerVisitor* visitor) {
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return Namespace::InstanceSize();
 }
 
 
 bool RawCode::ContainsPC(RawObject* raw_obj, uword pc) {
-  uword tags = raw_obj->ptr()->tags_;
+  uint32_t tags = raw_obj->ptr()->tags_;
   if (RawObject::ClassIdTag::decode(tags) == kCodeCid) {
     RawCode* raw_code = reinterpret_cast<RawCode*>(raw_obj);
     return RawInstructions::ContainsPC(raw_code->ptr()->instructions_, pc);
   }
   return false;
 }
 
 
 intptr_t RawCode::VisitCodePointers(RawCode* raw_obj,
                                     ObjectPointerVisitor* visitor) {
@@ skipping 192 matching lines @@
     ObjectPointerVisitor* visitor) {
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return UnwindError::InstanceSize();
 }
 
 
 intptr_t RawInstance::VisitInstancePointers(RawInstance* raw_obj,
                                             ObjectPointerVisitor* visitor) {
   // Make sure that we got here with the tagged pointer as this.
   ASSERT(raw_obj->IsHeapObject());
-  uword tags = raw_obj->ptr()->tags_;
+  uint32_t tags = raw_obj->ptr()->tags_;
   intptr_t instance_size = SizeTag::decode(tags);
   if (instance_size == 0) {
     RawClass* cls =
         visitor->isolate()->GetClassForHeapWalkAt(raw_obj->GetClassId());
     instance_size = cls->ptr()->instance_size_in_words_ << kWordSizeLog2;
   }
 
   // Calculate the first and last raw object pointer fields.
   uword obj_addr = RawObject::ToAddr(raw_obj);
   uword from = obj_addr + sizeof(RawObject);
@@ skipping 252 matching lines @@
 intptr_t RawUserTag::VisitUserTagPointers(RawUserTag* raw_obj,
                                           ObjectPointerVisitor* visitor) {
   // Make sure that we got here with the tagged pointer as this.
   ASSERT(raw_obj->IsHeapObject());
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return UserTag::InstanceSize();
 }
 
 
 }  // namespace dart