Correctly recognize external strings.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1879 matching lines @@
 
     // Disallow copying and assigning.
     Value(const Value&);
     void operator=(const Value&);
   };
 
  private:
   void VerifyExternalStringResourceBase(ExternalStringResourceBase* v,
                                         Encoding encoding) const;
   void VerifyExternalStringResource(ExternalStringResource* val) const;
+  static internal::Object* GetRedirectedString(internal::Object* cons);
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript symbol (ECMA-262 edition 6)
  *
  * This is an experimental feature. Use at your own risk.
  */
 class V8_EXPORT Symbol : public Primitive {
@@ skipping 3471 matching lines @@
   static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSize;
   static const int kStringResourceOffset = 3 * kApiPointerSize;
 
   static const int kOddballKindOffset = 3 * kApiPointerSize;
   static const int kForeignAddressOffset = kApiPointerSize;
   static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
   static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
   static const int kContextHeaderSize = 2 * kApiPointerSize;
   static const int kContextEmbedderDataIndex = 65;
   static const int kFullStringRepresentationMask = 0x07;
+  static const int kStringRepresentationMask = 0x03;
   static const int kStringEncodingMask = 0x4;
+  static const int kConsTwoByteRepresentationTag = 0x01;
   static const int kExternalTwoByteRepresentationTag = 0x02;
-  static const int kExternalAsciiRepresentationTag = 0x06;
+  static const int kConsRepresentationTag = 0x01;
+  static const int kExternalRepresentationTag = 0x02;
 
   static const int kIsolateEmbedderDataOffset = 0 * kApiPointerSize;
   static const int kIsolateRootsOffset = 5 * kApiPointerSize;
   static const int kUndefinedValueRootIndex = 5;
   static const int kNullValueRootIndex = 7;
   static const int kTrueValueRootIndex = 8;
   static const int kFalseValueRootIndex = 9;
   static const int kEmptyStringRootIndex = 146;
 
   static const int kNodeClassIdOffset = 1 * kApiPointerSize;
@@ skipping 43 matching lines @@
     typedef internal::Object O;
     O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
     return ReadField<uint8_t>(map, kMapInstanceTypeOffset);
   }
 
   V8_INLINE static int GetOddballKind(internal::Object* obj) {
     typedef internal::Object O;
     return SmiValue(ReadField<O*>(obj, kOddballKindOffset));
   }
 
-  V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
-    int representation = (instance_type & kFullStringRepresentationMask);
-    return representation == kExternalTwoByteRepresentationTag;
-  }
-
   V8_INLINE static uint8_t GetNodeFlag(internal::Object** obj, int shift) {
       uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
       return *addr & static_cast<uint8_t>(1U << shift);
   }
 
   V8_INLINE static void UpdateNodeFlag(internal::Object** obj,
                                        bool value, int shift) {
       uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
       uint8_t mask = static_cast<uint8_t>(1 << shift);
       *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
@@ skipping 512 matching lines @@
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kEmptyStringRootIndex);
   return Local<String>(reinterpret_cast<String*>(slot));
 }
 
 
 String::ExternalStringResource* String::GetExternalStringResource() const {
   typedef internal::Object O;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
-  String::ExternalStringResource* result;
-  if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
+  String::ExternalStringResource* result = NULL;
+  int type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
+  // Resolve redirected string via cons string.
+  if (type == I::kConsTwoByteRepresentationTag) {
+    obj = GetRedirectedString(obj);
+    type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
+  }
+  if (type == I::kExternalTwoByteRepresentationTag) {
     void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
-  } else {
-    result = NULL;
   }
 #ifdef V8_ENABLE_CHECKS
   VerifyExternalStringResource(result);
 #endif
   return result;
 }
 
 
 String::ExternalStringResourceBase* String::GetExternalStringResourceBase(

[dcarney, 2014/02/04 15:10:05]

this function is ridiculously hot in some dromaeo benchmark, so you can't land
it like this.
maybe try doing some reordering

if (string_type == I::kExternalRepresentationTag) {
  return ...
} else if (string_type != I::kConsRepresentationTag) {
  return NULL;
}
return slow_case()

     String::Encoding* encoding_out) const {
   typedef internal::Object O;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
-  int type = I::GetInstanceType(obj) & I::kFullStringRepresentationMask;
-  *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
+  int instance_type = I::GetInstanceType(obj);
+  int string_type = instance_type & I::kStringRepresentationMask;
+  *encoding_out = static_cast<Encoding>(instance_type & I::kStringEncodingMask);
   ExternalStringResourceBase* resource = NULL;
-  if (type == I::kExternalAsciiRepresentationTag ||
-      type == I::kExternalTwoByteRepresentationTag) {
+  // Resolve redirected string via cons string.
+  if (string_type == I::kConsRepresentationTag) {
+    obj = GetRedirectedString(obj);
+    string_type = I::GetInstanceType(obj) & I::kStringRepresentationMask;
+  }
+  if (string_type == I::kExternalRepresentationTag) {
     void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
     resource = static_cast<ExternalStringResourceBase*>(value);
   }
 #ifdef V8_ENABLE_CHECKS
     VerifyExternalStringResourceBase(resource, *encoding_out);
 #endif
   return resource;
 }
 
 
@@ skipping 411 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_