Revert r12430, r12432, r12433 (basic support for Latin1).

src/heap.cc

 // 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 30 matching lines @@
 #include "mark-compact.h"
 #include "natives.h"
 #include "objects-visiting.h"
 #include "objects-visiting-inl.h"
 #include "once.h"
 #include "runtime-profiler.h"
 #include "scopeinfo.h"
 #include "snapshot.h"
 #include "store-buffer.h"
 #include "v8threads.h"
-#include "v8utils.h"
 #include "vm-state-inl.h"
 #if V8_TARGET_ARCH_ARM && !V8_INTERPRETED_REGEXP
 #include "regexp-macro-assembler.h"
 #include "arm/regexp-macro-assembler-arm.h"
 #endif
 #if V8_TARGET_ARCH_MIPS && !V8_INTERPRETED_REGEXP
 #include "regexp-macro-assembler.h"
 #include "mips/regexp-macro-assembler-mips.h"
 #endif
 
@@ skipping 4322 matching lines @@
   object->set_map(constructor->initial_map());
 
   // Reinitialize the object from the constructor map.
   InitializeJSObjectFromMap(object, FixedArray::cast(properties), map);
   return object;
 }
 
 
 MaybeObject* Heap::AllocateStringFromAscii(Vector<const char> string,
                                            PretenureFlag pretenure) {
-  int length = string.length();
-  if (length == 1) {
+  if (string.length() == 1) {
     return Heap::LookupSingleCharacterStringFromCode(string[0]);
   }
   Object* result;
   { MaybeObject* maybe_result =
         AllocateRawAsciiString(string.length(), pretenure);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
-  isolate_->counters()->string_length_ascii()->Increment(length);
-
   // Copy the characters into the new object.
-  CopyChars(SeqAsciiString::cast(result)->GetChars(), string.start(), length);
+  SeqAsciiString* string_result = SeqAsciiString::cast(result);
+  for (int i = 0; i < string.length(); i++) {
+    string_result->SeqAsciiStringSet(i, string[i]);
+  }
   return result;
 }
 
 
 MaybeObject* Heap::AllocateStringFromUtf8Slow(Vector<const char> string,
                                               PretenureFlag pretenure) {
   // Count the number of characters in the UTF-8 string and check if
   // it is an ASCII string.
   Access<UnicodeCache::Utf8Decoder>
       decoder(isolate_->unicode_cache()->utf8_decoder());
   decoder->Reset(string.start(), string.length());
   int chars = 0;
   while (decoder->has_more()) {
     uint32_t r = decoder->GetNext();
     if (r <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
       chars++;
     } else {
       chars += 2;
     }
   }
 
   Object* result;
   { MaybeObject* maybe_result = AllocateRawTwoByteString(chars, pretenure);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
-  isolate_->counters()->string_length_utf8()->Increment(chars);
-
   // Convert and copy the characters into the new object.
-  SeqTwoByteString* twobyte = SeqTwoByteString::cast(result);
+  String* string_result = String::cast(result);
   decoder->Reset(string.start(), string.length());
   int i = 0;
   while (i < chars) {
     uint32_t r = decoder->GetNext();
     if (r > unibrow::Utf16::kMaxNonSurrogateCharCode) {
-      twobyte->SeqTwoByteStringSet(i++, unibrow::Utf16::LeadSurrogate(r));
-      twobyte->SeqTwoByteStringSet(i++, unibrow::Utf16::TrailSurrogate(r));
+      string_result->Set(i++, unibrow::Utf16::LeadSurrogate(r));
+      string_result->Set(i++, unibrow::Utf16::TrailSurrogate(r));
     } else {
-      twobyte->SeqTwoByteStringSet(i++, r);
+      string_result->Set(i++, r);
     }
   }
   return result;
 }
 
 
-MaybeObject* Heap::AllocateStringFromLatin1Slow(Vector<const char> string,
-                                                PretenureFlag pretenure) {
-  int chars = string.length();
-  Object* result;
-  { MaybeObject* maybe_result = AllocateRawTwoByteString(chars, pretenure);
-    if (!maybe_result->ToObject(&result)) return maybe_result;
-  }
-
-  isolate_->counters()->string_length_latin1()->Increment(chars);
-
-  // Convert and copy the characters into the new object.
-  SeqTwoByteString* string_result = SeqTwoByteString::cast(result);
-  CopyChars(string_result->GetChars(),
-            reinterpret_cast<const unsigned char*>(string.start()),
-            chars);
-  return result;
-}
-
-
 MaybeObject* Heap::AllocateStringFromTwoByte(Vector<const uc16> string,
                                              PretenureFlag pretenure) {
   // Check if the string is an ASCII string.
+  MaybeObject* maybe_result;
+  if (String::IsAscii(string.start(), string.length())) {
+    maybe_result = AllocateRawAsciiString(string.length(), pretenure);
+  } else {  // It's not an ASCII string.
+    maybe_result = AllocateRawTwoByteString(string.length(), pretenure);
+  }
   Object* result;
-  int length = string.length();
-  const uc16* start = string.start();
+  if (!maybe_result->ToObject(&result)) return maybe_result;
 
-  if (String::IsAscii(start, length)) {
-    MaybeObject* maybe_result = AllocateRawAsciiString(length, pretenure);
-    if (!maybe_result->ToObject(&result)) return maybe_result;
-    isolate_->counters()->string_length_ascii()->Increment(length);
-    CopyChars(SeqAsciiString::cast(result)->GetChars(), start, length);
-  } else {  // It's not an ASCII string.
-    MaybeObject* maybe_result = AllocateRawTwoByteString(length, pretenure);
-    if (!maybe_result->ToObject(&result)) return maybe_result;
-    isolate_->counters()->string_length_utf16()->Increment(length);
-    CopyChars(SeqTwoByteString::cast(result)->GetChars(), start, length);
+  // Copy the characters into the new object, which may be either ASCII or
+  // UTF-16.
+  String* string_result = String::cast(result);
+  for (int i = 0; i < string.length(); i++) {
+    string_result->Set(i, string[i]);
   }
-
   return result;
 }
 
 
 Map* Heap::SymbolMapForString(String* string) {
   // If the string is in new space it cannot be used as a symbol.
   if (InNewSpace(string)) return NULL;
 
   // Find the corresponding symbol map for strings.
   switch (string->map()->instance_type()) {
@@ skipping 2843 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal