VM: Reland Inline instance object hash code into object header on 64bit.

runtime/vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 737 matching lines @@
     const Object& obj = *objects_[i].obj_;
 
     NoSafepointScope no_safepoint;
     uword start = reinterpret_cast<uword>(obj.raw()) - kHeapObjectTag;
     uword end = start + obj.raw()->Size();
 
     // Write object header with the mark and VM heap bits set.
     uword marked_tags = obj.raw()->ptr()->tags_;
     marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
     marked_tags = RawObject::MarkBit::update(true, marked_tags);
+#if defined(HASH_IN_OBJECT_HEADER)
+    marked_tags |= static_cast<uword>(obj.raw()->ptr()->hash_) << 32;
+#endif
     stream->WriteWord(marked_tags);
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
          cursor < reinterpret_cast<uword*>(end); cursor++) {
       stream->WriteWord(*cursor);
     }
   }
 }
 
 
@@ skipping 66 matching lines @@
     {
       NoSafepointScope no_safepoint;
 
       uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
       uword entry = beginning + Instructions::HeaderSize();
 
       // Write Instructions with the mark and VM heap bits set.
       uword marked_tags = insns.raw_ptr()->tags_;
       marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
       marked_tags = RawObject::MarkBit::update(true, marked_tags);
+#if defined(HASH_IN_OBJECT_HEADER)
+      // Can't use GetObjectTagsAndHash because the update methods discard the
+      // high bits.
+      marked_tags |= static_cast<uword>(insns.raw_ptr()->hash_) << 32;
+#endif
 
       WriteWordLiteralText(marked_tags);
       beginning += sizeof(uword);
 
       WriteByteSequence(beginning, entry);
     }
 
     // 2. Write a label at the entry point.
     // Linux's perf uses these labels.
     owner = code.owner();
@@ skipping 185 matching lines @@
     payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
     uword end = entry + payload_size;
 
     ASSERT(Utils::IsAligned(beginning, sizeof(uword)));
     ASSERT(Utils::IsAligned(entry, sizeof(uword)));
 
     // Write Instructions with the mark and VM heap bits set.
     uword marked_tags = insns.raw_ptr()->tags_;
     marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
     marked_tags = RawObject::MarkBit::update(true, marked_tags);
+#if defined(HASH_IN_OBJECT_HEADER)
+    // Can't use GetObjectTagsAndHash because the update methods discard the
+    // high bits.
+    marked_tags |= static_cast<uword>(insns.raw_ptr()->hash_) << 32;
+#endif
 
     instructions_blob_stream_.WriteWord(marked_tags);
     beginning += sizeof(uword);
 
     for (uword* cursor = reinterpret_cast<uword*>(beginning);
          cursor < reinterpret_cast<uword*>(end); cursor++) {
       instructions_blob_stream_.WriteWord(*cursor);
     }
   }
 }
@@ skipping 284 matching lines @@
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 
-uword SnapshotWriter::GetObjectTags(RawObject* raw) {
+uint32_t SnapshotWriter::GetObjectTags(RawObject* raw) {
   return raw->ptr()->tags_;
 }
 
 
+uword SnapshotWriter::GetObjectTagsAndHash(RawObject* raw) {
+  uword result = raw->ptr()->tags_;
+#if defined(HASH_IN_OBJECT_HEADER)
+  result |= static_cast<uword>(raw->ptr()->hash_) << 32;
+#endif
+  return result;
+}
+
+
 #define VM_OBJECT_CLASS_LIST(V)                                                \
   V(OneByteString)                                                             \
   V(TwoByteString)                                                             \
   V(Mint)                                                                      \
   V(Bigint)                                                                    \
   V(Double)                                                                    \
   V(ImmutableArray)
 
 #define VM_OBJECT_WRITE(clazz)                                                 \
   case clazz::kClassId: {                                                      \
@@ skipping 203 matching lines @@
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw, bool as_reference) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   // When we know that we are dealing with leaf or shallow objects we write
   // these objects inline even when 'as_reference' is true.
   const bool write_as_reference = as_reference && !raw->IsCanonical();
-  intptr_t tags = raw->ptr()->tags_;
+  uintptr_t tags = GetObjectTagsAndHash(raw);
 
   // Add object to the forward ref list and mark it so that future references
   // to this object in the snapshot will use this object id. Mark the
   // serialization state so that we do the right thing when we go through
   // the forward list.
   intptr_t class_id = raw->GetClassId();
   intptr_t object_id;
   if (write_as_reference && IsSplitClassId(class_id)) {
     object_id = forward_list_->AddObject(zone(), raw, kIsNotSerialized);
   } else {
@@ skipping 56 matching lines @@
 
 
 class WriteInlinedObjectVisitor : public ObjectVisitor {
  public:
   explicit WriteInlinedObjectVisitor(SnapshotWriter* writer)
       : writer_(writer) {}
 
   virtual void VisitObject(RawObject* obj) {
     intptr_t object_id = writer_->forward_list_->FindObject(obj);
     ASSERT(object_id != kInvalidIndex);
-    intptr_t tags = writer_->GetObjectTags(obj);
+    intptr_t tags = MessageWriter::GetObjectTagsAndHash(obj);
     writer_->WriteMarkedObjectImpl(obj, tags, object_id, kAsInlinedObject);
   }
 
  private:
   SnapshotWriter* writer_;
 };
 
 
 void SnapshotWriter::WriteForwardedObjects() {
   WriteInlinedObjectVisitor visitor(this);
@@ skipping 144 matching lines @@
       thread()->zone(),
       "Illegal argument in isolate message : (object is a closure - %s)",
       errorFunc.ToCString());
   SetWriteException(Exceptions::kArgument, chars);
   return Function::null();
 }
 
 
 RawClass* SnapshotWriter::GetFunctionOwner(RawFunction* func) {
   RawObject* owner = func->ptr()->owner_;
-  uword tags = GetObjectTags(owner);
+  uint32_t tags = GetObjectTags(owner);
   intptr_t class_id = RawObject::ClassIdTag::decode(tags);
   if (class_id == kClassCid) {
     return reinterpret_cast<RawClass*>(owner);
   }
   ASSERT(class_id == kPatchClassCid);
   return reinterpret_cast<RawPatchClass*>(owner)->ptr()->patched_class_;
 }
 
 
 void SnapshotWriter::CheckForNativeFields(RawClass* cls) {
@@ skipping 210 matching lines @@
       *buffer_len_ = BytesWritten();
     }
   } else {
     FreeBuffer();
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart