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

runtime/vm/object.h

Index: runtime/vm/object.h
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index a37a146bd53da92bf88db05f726f2d161288e8d2..a54e2f7eab87d8669cb930aacd1af1a70b970167 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -245,9 +245,9 @@ class Object {
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) { initializeHandle(this, value); }
 
-  uint32_t CompareAndSwapTags(uint32_t old_tags, uint32_t new_tags) const {
-    return AtomicOperations::CompareAndSwapUint32(&raw()->ptr()->tags_,
-                                                  old_tags, new_tags);
+  uword CompareAndSwapTags(uword old_tags, uword new_tags) const {
+    return AtomicOperations::CompareAndSwapWord(&raw()->ptr()->tags_, old_tags,
+                                                new_tags);
   }
   bool IsCanonical() const { return raw()->IsCanonical(); }
   void SetCanonical() const { raw()->SetCanonical(); }
@@ -434,11 +434,13 @@ class Object {
 
 #if defined(HASH_IN_OBJECT_HEADER)
   static uint32_t GetCachedHash(const RawObject* obj) {
-    return obj->ptr()->hash_;
+    uword tags = obj->ptr()->tags_;
+    return tags >> 32;
   }
 
-  static void SetCachedHash(RawObject* obj, uint32_t hash) {
-    obj->ptr()->hash_ = hash;
+  static void SetCachedHash(RawObject* obj, uintptr_t hash) {
+    ASSERT(hash >> 32 == 0);
+    obj->ptr()->tags_ |= hash << 32;
   }
 #endif
 
@@ -6829,14 +6831,16 @@ class String : public Instance {
     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);