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

src/heap.h

 // 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 58 matching lines @@
   V(Map, global_context_map, GlobalContextMap)                                 \
   V(Map, fixed_array_map, FixedArrayMap)                                       \
   V(Map, serialized_scope_info_map, SerializedScopeInfoMap)                    \
   V(Map, fixed_cow_array_map, FixedCOWArrayMap)                                \
   V(Map, fixed_double_array_map, FixedDoubleArrayMap)                          \
   V(Object, no_interceptor_result_sentinel, NoInterceptorResultSentinel)       \
   V(Map, meta_map, MetaMap)                                                    \
   V(Map, hash_table_map, HashTableMap)                                         \
   V(Smi, stack_limit, StackLimit)                                              \
   V(FixedArray, number_string_cache, NumberStringCache)                        \
+  V(FixedArray, string_locks, StringLocks)                        \
   V(Object, instanceof_cache_function, InstanceofCacheFunction)                \
   V(Object, instanceof_cache_map, InstanceofCacheMap)                          \
   V(Object, instanceof_cache_answer, InstanceofCacheAnswer)                    \
   V(FixedArray, single_character_string_cache, SingleCharacterStringCache)     \
   V(FixedArray, string_split_cache, StringSplitCache)                          \
   V(Object, termination_exception, TerminationException)                       \
   V(FixedArray, empty_fixed_array, EmptyFixedArray)                            \
   V(ByteArray, empty_byte_array, EmptyByteArray)                               \
   V(FixedDoubleArray, empty_fixed_double_array, EmptyFixedDoubleArray)         \
   V(String, empty_string, EmptyString)                                         \
@@ skipping 1111 matching lines @@
   //
   // Support for the API.
   //
 
   bool CreateApiObjects();
 
   // Attempt to find the number in a small cache.  If we finds it, return
   // the string representation of the number.  Otherwise return undefined.
   Object* GetNumberStringCache(Object* number);
 
+  // Locks a string to prevent changes to the string's representation or
+  // encoding, e.g., due to externalization.
+  // It does not prevent moving the string during a GC
+  // (i.e., it's not a way to keep a pointer to an underlying character
+  // sequence valid). Might fail if the underlying data structure can't
+  // grow to accomodate the string, otherwise returns the string itself.
+  MaybeObject* LockString(String* string);
+  // Removes the lock on the string.
+  void UnlockString(String* string);
+  // Check if a string is locked.
+  bool IsStringLocked(String* string);
+  // Initializes the data structure underlying LockString.
+  MaybeObject* InitializeStringLocks();
+
   // Update the cache with a new number-string pair.
   void SetNumberStringCache(Object* number, String* str);
 
   // Adjusts the amount of registered external memory.
   // Returns the adjusted value.
   inline int AdjustAmountOfExternalAllocatedMemory(int change_in_bytes);
 
   // Allocate uninitialized fixed array.
   MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(int length);
   MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(int length,
@@ skipping 1257 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #undef HEAP
 
 #endif  // V8_HEAP_H_