Correctly hook up back references to internalized strings in code deserializer.

src/objects-inl.h

Index: src/objects-inl.h
diff --git a/src/objects-inl.h b/src/objects-inl.h
index 0aca5cfcdb488b0718af22d18c95afc69a17da19..d304b8d6170d21ab8ed93fadf7a8e0a8d35ebde9 100644
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -6580,6 +6580,31 @@ bool String::AsArrayIndex(uint32_t* index) {
 }
 
 
+void String::SetForwardedInternalizedString(String* canonical) {
+  ASSERT(IsInternalizedString());
+  ASSERT(HasHashCode());
+  if (canonical == this) return;  // No need to forward.
+  ASSERT(SlowEquals(canonical));
+  ASSERT(canonical->IsInternalizedString());
+  ASSERT(canonical->HasHashCode());
+  WRITE_FIELD(this, kHashFieldOffset, canonical);
+  // With canonical being a string, the LSB is set.  Interpreted as hash code,
+  // this means that the hash code uninitialized.  We use this for distinction.
+  ASSERT(!HasHashCode());

[mvstanton, 2014/07/22 13:31:31]

How about words along this line?

"Setting a tagged value (canonical) in the hash code causes the hash code to be
interpreted as uninitialized. We use this fact to recognize that we have a
forwarded string."

[Yang, 2014/07/23 06:55:58]

Done.

+}
+
+
+String* String::GetForwardedInternalizedString() {
+  ASSERT(IsInternalizedString());
+  if (HasHashCode()) return this;
+  String* canonical = String::cast(READ_FIELD(this, kHashFieldOffset));
+  ASSERT(canonical->IsInternalizedString());
+  ASSERT(SlowEquals(canonical));
+  ASSERT(canonical->HasHashCode());
+  return canonical;
+}
+
+
 Object* JSReceiver::GetConstructor() {
   return map()->constructor();
 }