Allow the morphing of strings to external strings to avoid having to...

src/heap.cc

 // Copyright 2006-2008 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 1501 matching lines @@
   ExternalAsciiString* external_string = ExternalAsciiString::cast(result);
   external_string->set_length(length);
   external_string->set_resource(resource);
 
   return result;
 }
 
 
 Object* Heap::AllocateExternalStringFromTwoByte(
     ExternalTwoByteString::Resource* resource) {
-  Map* map;
   int length = resource->length();
-  if (length <= String::kMaxShortStringSize) {
-    map = short_external_string_map();
-  } else if (length <= String::kMaxMediumStringSize) {
-    map = medium_external_string_map();
-  } else {
-    map = long_external_string_map();
-  }
 
+  Map* map = ExternalTwoByteString::StringMap(length);
   Object* result = Allocate(map, NEW_SPACE);
   if (result->IsFailure()) return result;
 
   ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
   external_string->set_length(length);
   external_string->set_resource(resource);
 
   return result;
 }
 
 
 Object* Heap::AllocateExternalSymbolFromTwoByte(
     ExternalTwoByteString::Resource* resource) {
-  Map* map;
   int length = resource->length();
-  if (length <= String::kMaxShortStringSize) {
-    map = short_external_symbol_map();
-  } else if (length <= String::kMaxMediumStringSize) {
-    map = medium_external_symbol_map();
-  } else {
-    map = long_external_symbol_map();
-  }
 
+  Map* map = ExternalTwoByteString::SymbolMap(length);
   Object* result = Allocate(map, OLD_DATA_SPACE);
   if (result->IsFailure()) return result;
 
   ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
   external_string->set_length(length);
   external_string->set_resource(resource);
 
   return result;
 }
 
@@ skipping 46 matching lines @@
   Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
 
   if (result->IsFailure()) return result;
 
   reinterpret_cast<Array*>(result)->set_map(byte_array_map());
   reinterpret_cast<Array*>(result)->set_length(length);
   return result;
 }
 
 
+void Heap::CreateFillerObjectAt(Address addr, int size) {
+  if (size == 0) return;
+  HeapObject* filler = HeapObject::FromAddress(addr);
+  if (size == kPointerSize) {
+    filler->set_map(Heap::one_word_filler_map());
+  } else {
+    filler->set_map(Heap::byte_array_map());
+    ByteArray::cast(filler)->set_length(ByteArray::LengthFor(size));
+  }
+}
+
+
 Object* Heap::CreateCode(const CodeDesc& desc,
                          ScopeInfo<>* sinfo,
                          Code::Flags flags,
                          Code** self_reference) {
   // Compute size
   int body_size = RoundUp(desc.instr_size + desc.reloc_size, kObjectAlignment);
   int sinfo_size = 0;
   if (sinfo != NULL) sinfo_size = sinfo->Serialize(NULL);
   int obj_size = Code::SizeFor(body_size, sinfo_size);
   Object* result;
@@ skipping 431 matching lines @@
   if (map == short_sliced_ascii_string_map()) {
     return short_sliced_ascii_symbol_map();
   }
   if (map == medium_sliced_ascii_string_map()) {
     return medium_sliced_ascii_symbol_map();
   }
   if (map == long_sliced_ascii_string_map()) {
     return long_sliced_ascii_symbol_map();
   }
 
-  if (map == short_external_string_map()) return short_external_string_map();
-  if (map == medium_external_string_map()) return medium_external_string_map();
-  if (map == long_external_string_map()) return long_external_string_map();
+  if (map == short_external_string_map()) {
+    return short_external_symbol_map();
+  }
+  if (map == medium_external_string_map()) {
+    return medium_external_symbol_map();
+  }
+  if (map == long_external_string_map()) {
+    return long_external_symbol_map();
+  }
 
   if (map == short_external_ascii_string_map()) {
-    return short_external_ascii_string_map();
+    return short_external_ascii_symbol_map();
   }
   if (map == medium_external_ascii_string_map()) {
-    return medium_external_ascii_string_map();
+    return medium_external_ascii_symbol_map();
   }
   if (map == long_external_ascii_string_map()) {
-    return long_external_ascii_string_map();
+    return long_external_ascii_symbol_map();
   }
 
   // No match found.
   return NULL;
 }
 
 
 Object* Heap::AllocateInternalSymbol(unibrow::CharacterStream* buffer,
                                      int chars,
                                      uint32_t length_field) {
@@ skipping 1258 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal