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

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 RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 227 matching lines @@
 #define MINT_OBJECT_IMPLEMENTATION(object, rettype, super)                     \
   FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, rettype, super)
 
 class Object {
  public:
   virtual ~Object() {}
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) { initializeHandle(this, value); }
 
-  uword CompareAndSwapTags(uword old_tags, uword new_tags) const {
-    return AtomicOperations::CompareAndSwapWord(&raw()->ptr()->tags_, old_tags,
-                                                new_tags);
+  uint32_t CompareAndSwapTags(uint32_t old_tags, uint32_t new_tags) const {
+    return AtomicOperations::CompareAndSwapUint32(&raw()->ptr()->tags_,
+                                                  old_tags, new_tags);
   }
   bool IsCanonical() const { return raw()->IsCanonical(); }
   void SetCanonical() const { raw()->SetCanonical(); }
   void ClearCanonical() const { raw()->ClearCanonical(); }
   intptr_t GetClassId() const {
     return !raw()->IsHeapObject() ? static_cast<intptr_t>(kSmiCid)
                                   : raw()->GetClassId();
   }
   inline RawClass* clazz() const;
   static intptr_t tags_offset() { return OFFSET_OF(RawObject, tags_); }
@@ skipping 166 matching lines @@
   }
   // Value marking that we are transitioning from sentinel, e.g., computing
   // a field value. Used to detect circular initialization.
   static const Instance& transition_sentinel() {
     ASSERT(transition_sentinel_ != NULL);
     return *transition_sentinel_;
   }
 
 #if defined(HASH_IN_OBJECT_HEADER)
   static uint32_t GetCachedHash(const RawObject* obj) {
-    uword tags = obj->ptr()->tags_;
-    return tags >> 32;
+    return obj->ptr()->hash_;
   }
 
-  static void SetCachedHash(RawObject* obj, uintptr_t hash) {
-    ASSERT(hash >> 32 == 0);
-    obj->ptr()->tags_ |= hash << 32;
+  static void SetCachedHash(RawObject* obj, uint32_t hash) {
+    obj->ptr()->hash_ = hash;
   }
 #endif
 
   // Compiler's constant propagation constants.
   static const Instance& unknown_constant() {
     ASSERT(unknown_constant_ != NULL);
     return *unknown_constant_;
   }
   static const Instance& non_constant() {
     ASSERT(non_constant_ != NULL);
@@ skipping 6354 matching lines @@
   intptr_t Hash() const {
     intptr_t result = GetCachedHash(raw());
     if (result != 0) {
       return result;
     }
     result = String::Hash(*this, 0, this->Length());
     SetCachedHash(raw(), result);
     return result;
   }
 
+  static intptr_t Hash(RawString* raw);
+
   bool HasHash() const {
     ASSERT(Smi::New(0) == NULL);
     return GetCachedHash(raw()) != 0;
   }
 
-#if defined(HASH_IN_OBJECT_HEADER)
-  static intptr_t hash_offset() { return kInt32Size; }  // Wrong for big-endian?
-#else
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
-#endif
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const char* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const int32_t* characters, intptr_t len);
   static intptr_t HashRawSymbol(const RawString* symbol) {
     ASSERT(symbol->IsCanonical());
     intptr_t result = GetCachedHash(symbol);
     ASSERT(result != 0);
     return result;
   }
@@ skipping 2217 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_