Added ability to lock strings to prevent their representation or encoding from changing.

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 2328 matching lines @@
   { MaybeObject* maybe_obj = StringDictionary::Allocate(Runtime::kNumFunctions);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   { MaybeObject* maybe_obj = Runtime::InitializeIntrinsicFunctionNames(this,
                                                                        obj);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_intrinsic_function_names(StringDictionary::cast(obj));
 
   if (InitializeNumberStringCache()->IsFailure()) return false;
+  if (InitializeStringLocks()->IsFailure()) return false;
 
   // Allocate cache for single character ASCII strings.
   { MaybeObject* maybe_obj =
         AllocateFixedArray(String::kMaxAsciiCharCode + 1, TENURED);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_single_character_string_cache(FixedArray::cast(obj));
 
   // Allocate cache for string split.
   { MaybeObject* maybe_obj =
@@ skipping 196 matching lines @@
 
 MaybeObject* Heap::Uint32ToString(uint32_t value,
                                   bool check_number_string_cache) {
   Object* number;
   MaybeObject* maybe = NumberFromUint32(value);
   if (!maybe->To<Object>(&number)) return maybe;
   return NumberToString(number, check_number_string_cache);
 }
 
 
+MaybeObject* Heap::LockString(String* string) {
+  ASSERT(!string->IsConsString());
+  FixedArray* locks = string_locks();
+  ASSERT(locks->length() > 1);
+  int length = locks->length();
+  int element_count = Smi::cast(locks->get(0))->value();
+  int element_index = element_count + 1;
+  if (element_index >= length) {
+    int new_length = length * 2;
+    MaybeObject* allocation = AllocateFixedArray(new_length);
+    FixedArray* new_locks = NULL;  // Initialized to please compiler.
+    if (!allocation->To<FixedArray>(&new_locks)) return allocation;
+    for (int i = 1; i < length; i++) {
+      new_locks->set(i, locks->get(i));
+    }
+    set_string_locks(new_locks);
+    locks = new_locks;
+  }
+  locks->set(element_index, string);
+  locks->set(0, Smi::FromInt(element_index));
+  return string;
+}
+
+
+void Heap::UnlockString(String* string) {
+  FixedArray* locks = string_locks();
+  ASSERT(locks->length() > 1);
+  int element_count = Smi::cast(locks->get(0))->value();
+  ASSERT(element_count > 0);
+  ASSERT(element_count < locks->length());
+  for (int i = 1; i <= element_count; i++) {
+    String* element = String::cast(locks->get(i));
+    if (element == string) {
+      if (i < element_count) {
+        locks->set(i, locks->get(element_count));
+      }
+      locks->set_undefined(element_count);
+      locks->set(0, Smi::FromInt(element_count - 1));
+      return;
+    }
+  }
+  // We should have found the string. It's an error to try to unlock
+  // a string that hasn't been locked.
+  UNREACHABLE();
+}
+
+
+bool Heap::IsStringLocked(String* string) {
+  if (string->IsConsString()) return false;
+  FixedArray* locks = string_locks();
+  ASSERT(locks->length() > 1);
+  int element_count = Smi::cast(locks->get(0))->value();
+  for (int i = 1; i <= element_count; i++) {
+    if (locks->get(i) == string) return true;
+  }
+  return false;
+}
+
+
+MaybeObject* Heap::InitializeStringLocks() {
+  const int kInitialSize = 6;
+  MaybeObject* allocation = AllocateFixedArray(kInitialSize);
+  if (allocation->IsFailure()) return allocation;
+  FixedArray* new_array = FixedArray::cast(allocation->ToObjectUnchecked());
+  new_array->set(0, Smi::FromInt(0));
+  set_string_locks(new_array);
+  return new_array;
+}
+
+
 Map* Heap::MapForExternalArrayType(ExternalArrayType array_type) {
   return Map::cast(roots_[RootIndexForExternalArrayType(array_type)]);
 }
 
 
 Heap::RootListIndex Heap::RootIndexForExternalArrayType(
     ExternalArrayType array_type) {
   switch (array_type) {
     case kExternalByteArray:
       return kExternalByteArrayMapRootIndex;
@@ skipping 3826 matching lines @@
   }
   isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
   for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->Free(chunk);
   }
   chunks_queued_for_free_ = NULL;
 }
 
 } }  // namespace v8::internal