More compact string representation 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 414 matching lines @@
     ASSERT(sentinel_ != NULL);
     return *sentinel_;
   }
   // 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;
+  }
+
+  static void SetCachedHash(RawObject* obj, uintptr_t hash) {
+    ASSERT(hash >> 32 == 0);
+    obj->ptr()->tags_ |= hash << 32;
+  }
+#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);
     return *non_constant_;
   }
 
@@ skipping 6302 matching lines @@
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   static const intptr_t kOneByteChar = 1;
   static const intptr_t kTwoByteChar = 2;
 
   // All strings share the same maximum element count to keep things
   // simple.  We choose a value that will prevent integer overflow for
   // 2 byte strings, since it is the worst case.
-  static const intptr_t kSizeofRawString =
-      sizeof(RawInstance) + (2 * kWordSize);
+#if defined(HASH_IN_OBJECT_HEADER)
+  static const intptr_t kSizeofRawString = sizeof(RawInstance) + kWordSize;
+#else
+  static const intptr_t kSizeofRawString = sizeof(RawInstance) + 2 * kWordSize;
+#endif
   static const intptr_t kMaxElements = kSmiMax / kTwoByteChar;
 
   class CodePointIterator : public ValueObject {
    public:
     explicit CodePointIterator(const String& str)
         : str_(str), ch_(0), index_(-1), end_(str.Length()) {
       ASSERT(!str_.IsNull());
     }
 
     CodePointIterator(const String& str, intptr_t start, intptr_t length)
@@ skipping 15 matching lines @@
     int32_t ch_;
     intptr_t index_;
     intptr_t end_;
     DISALLOW_IMPLICIT_CONSTRUCTORS(CodePointIterator);
   };
 
   intptr_t Length() const { return Smi::Value(raw_ptr()->length_); }
   static intptr_t length_offset() { return OFFSET_OF(RawString, length_); }
 
   intptr_t Hash() const {
-    intptr_t result = Smi::Value(raw_ptr()->hash_);
+    intptr_t result = GetCachedHash(raw());
     if (result != 0) {
       return result;
     }
     result = String::Hash(*this, 0, this->Length());
-    this->SetHash(result);
+    SetCachedHash(raw(), result);
     return result;
   }
 
   bool HasHash() const {
     ASSERT(Smi::New(0) == NULL);
-    return (raw_ptr()->hash_ != 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 = Smi::Value(symbol->ptr()->hash_);
+    intptr_t result = GetCachedHash(symbol);
     ASSERT(result != 0);
     return result;
   }
 
   // Returns the hash of str1 + str2.
   static intptr_t HashConcat(const String& str1, const String& str2);
 
   virtual RawObject* HashCode() const { return Integer::New(Hash()); }
 
   uint16_t CharAt(intptr_t index) const;
@@ skipping 198 matching lines @@
       PRINTF_ATTRIBUTE(2, 3);
   static RawString* NewFormattedV(const char* format,
                                   va_list args,
                                   Heap::Space space = Heap::kNew);
 
   static bool ParseDouble(const String& str,
                           intptr_t start,
                           intptr_t end,
                           double* result);
 
+#if !defined(HASH_IN_OBJECT_HEADER)
+  static uint32_t GetCachedHash(const RawString* obj) {
+    return Smi::Value(obj->ptr()->hash_);
+  }
+
+  static void SetCachedHash(RawString* obj, uintptr_t hash) {
+    obj->ptr()->hash_ = Smi::New(hash);
+  }
+#endif
+
  protected:
   // These two operate on an array of Latin-1 encoded characters.
   // They are protected to avoid mistaking Latin-1 for UTF-8, but used
   // by friendly templated code (e.g., Symbols).
   bool Equals(const uint8_t* characters, intptr_t len) const;
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
-  void 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));
-  }
+  void SetHash(intptr_t value) const { SetCachedHash(raw(), value); }
 
   template <typename HandleType, typename ElementType, typename CallbackType>
   static void ReadFromImpl(SnapshotReader* reader,
                            String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            CallbackType new_symbol,
                            Snapshot::Kind kind);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(String, Instance);
@@ skipping 38 matching lines @@
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) ==
            OFFSET_OF_RETURNED_VALUE(RawOneByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawOneByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
+#if defined(HASH_IN_OBJECT_HEADER)
+    // We have to pad zero-length raw strings so that they can be externalized.
+    // If we don't pad, then the external string object does not fit in the
+    // memory allocated for the raw string.
+    if (len == 0) return InstanceSize(1);
+#endif
     return String::RoundedAllocationSize(sizeof(RawOneByteString) +
                                          (len * kBytesPerElement));
   }
 
   static RawOneByteString* New(intptr_t len, Heap::Space space);
   static RawOneByteString* New(const char* c_string,
                                Heap::Space space = Heap::kNew) {
     return New(reinterpret_cast<const uint8_t*>(c_string), strlen(c_string),
                space);
   }
@@ skipping 113 matching lines @@
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) ==
            OFFSET_OF_RETURNED_VALUE(RawTwoByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawTwoByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
+    // We have to pad zero-length raw strings so that they can be externalized.
+    // If we don't pad, then the external string object does not fit in the
+    // memory allocated for the raw string.
+    if (len == 0) return InstanceSize(1);
     return String::RoundedAllocationSize(sizeof(RawTwoByteString) +
                                          (len * kBytesPerElement));
   }
 
   static RawTwoByteString* New(intptr_t len, Heap::Space space);
   static RawTwoByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(intptr_t utf16_len,
                                const int32_t* characters,
@@ skipping 1673 matching lines @@
     return false;  // Two symbols that aren't identical aren't equal.
   }
   if (HasHash() && str.HasHash() && (Hash() != str.Hash())) {
     return false;  // Both sides have hash codes and they do not match.
   }
   return Equals(str, 0, str.Length());
 }
 
 
 intptr_t Library::UrlHash() const {
-  intptr_t result = Smi::Value(url()->ptr()->hash_);
+  intptr_t result = String::GetCachedHash(url());
   ASSERT(result != 0);
   return result;
 }
 
 
 void MegamorphicCache::SetEntry(const Array& array,
                                 intptr_t index,
                                 const Smi& class_id,
                                 const Function& target) {
   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
@@ skipping 73 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_