Promote and inflate string slices during scavenging GC.

src/heap.cc

 // Copyright 2011 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 1260 matching lines @@
 }
 
 
 template<LoggingAndProfiling logging_and_profiling_mode>
 class ScavengingVisitor : public StaticVisitorBase {
  public:
   static void Initialize() {
     table_.Register(kVisitSeqAsciiString, &EvacuateSeqAsciiString);
     table_.Register(kVisitSeqTwoByteString, &EvacuateSeqTwoByteString);
     table_.Register(kVisitShortcutCandidate, &EvacuateShortcutCandidate);
+    table_.Register(kVisitSlicedString, &EvacuateSlicedString);
     table_.Register(kVisitByteArray, &EvacuateByteArray);
     table_.Register(kVisitFixedArray, &EvacuateFixedArray);
     table_.Register(kVisitFixedDoubleArray, &EvacuateFixedDoubleArray);
 
     table_.Register(kVisitGlobalContext,
                     &ObjectEvacuationStrategy<POINTER_OBJECT>::
                         template VisitSpecialized<Context::kSize>);
 
     table_.Register(kVisitConsString,
                     &ObjectEvacuationStrategy<POINTER_OBJECT>::
                         template VisitSpecialized<ConsString::kSize>);
 
-    table_.Register(kVisitSlicedString,
-                    &ObjectEvacuationStrategy<POINTER_OBJECT>::
-                        template VisitSpecialized<SlicedString::kSize>);
-
     table_.Register(kVisitSharedFunctionInfo,
                     &ObjectEvacuationStrategy<POINTER_OBJECT>::
                         template VisitSpecialized<SharedFunctionInfo::kSize>);
 
     table_.Register(kVisitJSWeakMap,
                     &ObjectEvacuationStrategy<POINTER_OBJECT>::
                     Visit);
 
     table_.Register(kVisitJSRegExp,
                     &ObjectEvacuationStrategy<POINTER_OBJECT>::
@@ skipping 32 matching lines @@
     should_record = should_record || FLAG_log_gc;
     if (should_record) {
       if (heap->new_space()->Contains(obj)) {
         heap->new_space()->RecordAllocation(obj);
       } else {
         heap->new_space()->RecordPromotion(obj);
       }
     }
   }
 
-  // Helper function used by CopyObject to copy a source object to an
-  // allocated target object and update the forwarding pointer in the source
-  // object.  Returns the target object.
-  INLINE(static HeapObject* MigrateObject(Heap* heap,
-                                          HeapObject* source,
-                                          HeapObject* target,
-                                          int size)) {
-    // Copy the content of source to target.
-    heap->CopyBlock(target->address(), source->address(), size);
 
+  INLINE(static void ForwardAndLogMigration(Heap* heap,
+                                            HeapObject* source,
+                                            HeapObject* target)) {
     // Set the forwarding address.
     source->set_map_word(MapWord::FromForwardingAddress(target));
 
     if (logging_and_profiling_mode == LOGGING_AND_PROFILING_ENABLED) {
       // Update NewSpace stats if necessary.
       RecordCopiedObject(heap, target);
       HEAP_PROFILE(heap, ObjectMoveEvent(source->address(), target->address()));
       Isolate* isolate = heap->isolate();
       if (isolate->logger()->is_logging() ||
           CpuProfiler::is_profiling(isolate)) {
         if (target->IsSharedFunctionInfo()) {
           PROFILE(isolate, SharedFunctionInfoMoveEvent(
               source->address(), target->address()));
         }
       }
     }
+  }
+
+  // Helper function used by CopyObject to copy a source object to an
+  // allocated target object and update the forwarding pointer in the source
+  // object.  Returns the target object.
+  INLINE(static HeapObject* MigrateObject(Heap* heap,
+                                          HeapObject* source,
+                                          HeapObject* target,
+                                          int size)) {
+    // Copy the content of source to target.
+    heap->CopyBlock(target->address(), source->address(), size);
+
+    ForwardAndLogMigration(heap, source, target);
 
     return target;
   }
 
 
   template<ObjectContents object_contents, SizeRestriction size_restriction>
   static inline void EvacuateObject(Map* map,
                                     HeapObject** slot,
                                     HeapObject* object,
                                     int object_size) {
@@ skipping 12 matching lines @@
         if (object_contents == DATA_OBJECT) {
           maybe_result = heap->old_data_space()->AllocateRaw(object_size);
         } else {
           maybe_result = heap->old_pointer_space()->AllocateRaw(object_size);
         }
       }
 
       Object* result = NULL;  // Initialization to please compiler.
       if (maybe_result->ToObject(&result)) {
         HeapObject* target = HeapObject::cast(result);
-        *slot = MigrateObject(heap, object , target, object_size);
+        *slot = MigrateObject(heap, object, target, object_size);
 
         if (object_contents == POINTER_OBJECT) {
           heap->promotion_queue()->insert(target, object_size);
         }
 
         heap->tracer()->increment_promoted_objects_size(object_size);
         return;
       }
     }
     Object* result =
@@ skipping 45 matching lines @@
 
   static inline void EvacuateSeqTwoByteString(Map* map,
                                               HeapObject** slot,
                                               HeapObject* object) {
     int object_size = SeqTwoByteString::cast(object)->
         SeqTwoByteStringSize(map->instance_type());
     EvacuateObject<DATA_OBJECT, UNKNOWN_SIZE>(map, slot, object, object_size);
   }
 
 
+  static inline void EvacuateSlicedString(Map* map,
+                                          HeapObject** slot,
+                                          HeapObject* object) {
+    ASSERT(object->IsSlicedString());
+    Heap* heap = map->heap();
+    int slice_size = SlicedString::kSize;
+    if (heap->ShouldBePromoted(object->address(), slice_size)) {
+      SlicedString* slice = SlicedString::cast(object);
+      String* parent = slice->parent();
+
+      // Parent string might just have been moved and forwarded.
+      MapWord parent_word = parent->map_word();
+      if (parent_word.IsForwardingAddress()) {
+        parent = String::cast(parent_word.ToForwardingAddress());
+      }
+      ASSERT(!StringShape(parent).IsIndirect());
+
+      int length = slice->length();
+      // Allocate space for unpacked and truncated substring.
+      int size = parent->IsAsciiRepresentation()
+                 ? SeqAsciiString::SizeFor(length)
+                 : SeqTwoByteString::SizeFor(length);
+      MaybeObject* maybe_result;
+      if (size > Page::kMaxHeapObjectSize) {
+        maybe_result = heap->lo_space()->AllocateRawFixedArray(size);
+      } else {
+        maybe_result = heap->old_data_space()->AllocateRaw(size);
+      }
+
+      Object* result = NULL;
+      // Write substring to allocated space.
+      if (maybe_result->ToObject(&result)) {
+        int offset = slice->offset();
+        if (parent->IsAsciiRepresentation()) {
+          HeapObject::cast(result)->set_map(heap->ascii_string_map());
+          char* dest = SeqAsciiString::cast(result)->GetChars();
+          String::WriteToFlat(parent, dest, offset, length + offset);
+        } else {
+          HeapObject::cast(result)->set_map(heap->string_map());
+          uc16* dest = SeqTwoByteString::cast(result)->GetChars();
+          String::WriteToFlat(parent, dest, offset, length + offset);
+        }
+        ASSERT(!heap->InNewSpace(result));
+        String* string_result = String::cast(result);
+        string_result->set_length(length);
+        string_result->set_hash_field(parent->hash_field());
+
+        *slot = HeapObject::cast(result);
+        ForwardAndLogMigration(heap, object, *slot);
+
+        heap->tracer()->increment_promoted_objects_size(size);
+        return;
+      }
+      // If allocation failed, just skip promotion.
+    }
+    Object* result =
+        heap->new_space()->AllocateRaw(slice_size)->ToObjectUnchecked();
+    *slot = MigrateObject(heap, object, HeapObject::cast(result), slice_size);
+    return;
+  }
+
+
   static inline bool IsShortcutCandidate(int type) {
     return ((type & kShortcutTypeMask) == kShortcutTypeTag);
   }
 
   static inline void EvacuateShortcutCandidate(Map* map,
                                                HeapObject** slot,
                                                HeapObject* object) {
     ASSERT(IsShortcutCandidate(map->instance_type()));
 
     if (ConsString::cast(object)->unchecked_second() ==
@@ skipping 4663 matching lines @@
 }
 
 
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 } }  // namespace v8::internal