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

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, 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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 304 matching lines @@
     return true;
   }
 
   static RawObject* AllocateDouble(Thread* thread, double value) {
     const intptr_t instance_size = Double::InstanceSize();
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       uword tags = 0;
       tags = RawObject::ClassIdTag::update(kDoubleCid, tags);
       tags = RawObject::SizeTag::update(instance_size, tags);
+      // Also writes zero in the hash_ field.
       *reinterpret_cast<uword*>(start + Double::tags_offset()) = tags;
       *reinterpret_cast<double*>(start + Double::value_offset()) = value;
       return reinterpret_cast<RawObject*>(start + kHeapObjectTag);
     }
     return NULL;
   }
 
   static bool Double_add(Thread* thread, RawObject** FP, RawObject** result) {
     double d1, d2;
     if (!GetDoubleOperands(FrameArguments(FP, 2), &d1, &d2)) {
@@ skipping 2513 matching lines @@
   }
 
   // TODO(vegorov) allocation bytecodes can benefit from the new-space
   // allocation fast-path that does not transition into the runtime system.
   {
     BYTECODE(AllocateUninitializedContext, A_D);
     const uint16_t num_context_variables = rD;
     const intptr_t instance_size = Context::InstanceSize(num_context_variables);
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
-      uword tags = 0;
+      uint32_t tags = 0;
       tags = RawObject::ClassIdTag::update(kContextCid, tags);
       tags = RawObject::SizeTag::update(instance_size, tags);
+      // Also writes 0 in the hash_ field of the header.
       *reinterpret_cast<uword*>(start + Array::tags_offset()) = tags;
       *reinterpret_cast<uword*>(start + Context::num_variables_offset()) =
           num_context_variables;
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       pc += 2;
     }
     DISPATCH();
   }
 
   {
@@ skipping 20 matching lines @@
     DISPATCH();
   }
 
   {
     BYTECODE(AllocateOpt, A_D);
     const uword tags =
         static_cast<uword>(Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD))));
     const intptr_t instance_size = RawObject::SizeTag::decode(tags);
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
+      // Writes both the tags and the initial identity hash on 64 bit platforms.
       *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
       for (intptr_t current_offset = sizeof(RawInstance);
            current_offset < instance_size; current_offset += kWordSize) {
         *reinterpret_cast<RawObject**>(start + current_offset) = null_value;
       }
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       pc += 2;
     }
     DISPATCH();
   }
@@ skipping 11 matching lines @@
   }
 
   {
     BYTECODE(AllocateTOpt, A_D);
     const uword tags = Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD)));
     const intptr_t instance_size = RawObject::SizeTag::decode(tags);
     const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
     if (LIKELY(start != 0)) {
       RawObject* type_args = SP[0];
       const intptr_t type_args_offset = Bytecode::DecodeD(*pc);
+      // Writes both the tags and the initial identity hash on 64 bit platforms.
       *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
       for (intptr_t current_offset = sizeof(RawInstance);
            current_offset < instance_size; current_offset += kWordSize) {
         *reinterpret_cast<RawObject**>(start + current_offset) = null_value;
       }
       *reinterpret_cast<RawObject**>(start + type_args_offset) = type_args;
       FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
       SP -= 1;  // Consume the type arguments on the stack.
       pc += 4;
     }
@@ skipping 23 matching lines @@
             ~(kObjectAlignment - 1);
         const uword start =
             thread->heap()->new_space()->TryAllocate(instance_size);
         if (LIKELY(start != 0)) {
           const intptr_t cid = kArrayCid;
           uword tags = 0;
           if (LIKELY(instance_size <= RawObject::SizeTag::kMaxSizeTag)) {
             tags = RawObject::SizeTag::update(instance_size, tags);
           }
           tags = RawObject::ClassIdTag::update(cid, tags);
+          // Writes both the tags and the initial identity hash on 64 bit
+          // platforms.
           *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
           *reinterpret_cast<RawObject**>(start + Array::length_offset()) =
               FP[rB];
           *reinterpret_cast<RawObject**>(
               start + Array::type_arguments_offset()) = FP[rC];
           RawObject** data =
               reinterpret_cast<RawObject**>(start + Array::data_offset());
           for (intptr_t i = 0; i < length; i++) {
             data[i] = null_value;
           }
@@ skipping 915 matching lines @@
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC