RubyGems - therubyracer-heroku - Versions diffs - 0.8.1.pre2 → 0.8.1.pre3 - Mend

therubyracer-heroku 0.8.1.pre2 → 0.8.1.pre3

Files changed (1239) hide show

data/ext/v8/upstream/build/v8/src/execution.h DELETED Viewed

@@ -1,336 +0,0 @@
-// 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#ifndef V8_EXECUTION_H_
-#define V8_EXECUTION_H_
-namespace v8 {
-namespace internal {
-// Flag used to set the interrupt causes.
-enum InterruptFlag {
-  INTERRUPT = 1 << 0,
-  DEBUGBREAK = 1 << 1,
-  DEBUGCOMMAND = 1 << 2,
-  PREEMPT = 1 << 3,
-  TERMINATE = 1 << 4
-};
-class Execution : public AllStatic {
- public:
-  // Call a function, the caller supplies a receiver and an array
-  // of arguments. Arguments are Object* type. After function returns,
-  // pointers in 'args' might be invalid.
-  //
-  // *pending_exception tells whether the invoke resulted in
-  // a pending exception.
-  //
-  static Handle<Object> Call(Handle<JSFunction> func,
-                             Handle<Object> receiver,
-                             int argc,
-                             Object*** args,
-                             bool* pending_exception);
-  // Construct object from function, the caller supplies an array of
-  // arguments. Arguments are Object* type. After function returns,
-  // pointers in 'args' might be invalid.
-  //
-  // *pending_exception tells whether the invoke resulted in
-  // a pending exception.
-  //
-  static Handle<Object> New(Handle<JSFunction> func,
-                            int argc,
-                            Object*** args,
-                            bool* pending_exception);
-  // Call a function, just like Call(), but make sure to silently catch
-  // any thrown exceptions. The return value is either the result of
-  // calling the function (if caught exception is false) or the exception
-  // that occurred (if caught exception is true).
-  static Handle<Object> TryCall(Handle<JSFunction> func,
-                                Handle<Object> receiver,
-                                int argc,
-                                Object*** args,
-                                bool* caught_exception);
-  // ECMA-262 9.2
-  static Handle<Object> ToBoolean(Handle<Object> obj);
-  // ECMA-262 9.3
-  static Handle<Object> ToNumber(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.4
-  static Handle<Object> ToInteger(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.5
-  static Handle<Object> ToInt32(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.6
-  static Handle<Object> ToUint32(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.8
-  static Handle<Object> ToString(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.8
-  static Handle<Object> ToDetailString(Handle<Object> obj, bool* exc);
-  // ECMA-262 9.9
-  static Handle<Object> ToObject(Handle<Object> obj, bool* exc);
-  // Create a new date object from 'time'.
-  static Handle<Object> NewDate(double time, bool* exc);
-  // Used to implement [] notation on strings (calls JS code)
-  static Handle<Object> CharAt(Handle<String> str, uint32_t index);
-  static Handle<Object> GetFunctionFor();
-  static Handle<JSFunction> InstantiateFunction(
-      Handle<FunctionTemplateInfo> data, bool* exc);
-  static Handle<JSObject> InstantiateObject(Handle<ObjectTemplateInfo> data,
-                                            bool* exc);
-  static void ConfigureInstance(Handle<Object> instance,
-                                Handle<Object> data,
-                                bool* exc);
-  static Handle<String> GetStackTraceLine(Handle<Object> recv,
-                                          Handle<JSFunction> fun,
-                                          Handle<Object> pos,
-                                          Handle<Object> is_global);
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  static Object* DebugBreakHelper();
-  static void ProcessDebugMesssages(bool debug_command_only);
-#endif
-  // If the stack guard is triggered, but it is not an actual
-  // stack overflow, then handle the interruption accordingly.
-  static Object* HandleStackGuardInterrupt();
-  // Get a function delegate (or undefined) for the given non-function
-  // object. Used for support calling objects as functions.
-  static Handle<Object> GetFunctionDelegate(Handle<Object> object);
-  // Get a function delegate (or undefined) for the given non-function
-  // object. Used for support calling objects as constructors.
-  static Handle<Object> GetConstructorDelegate(Handle<Object> object);
-};
-class ExecutionAccess;
-// StackGuard contains the handling of the limits that are used to limit the
-// number of nested invocations of JavaScript and the stack size used in each
-// invocation.
-class StackGuard : public AllStatic {
- public:
-  // Pass the address beyond which the stack should not grow.  The stack
-  // is assumed to grow downwards.
-  static void SetStackLimit(uintptr_t limit);
-  // Threading support.
-  static char* ArchiveStackGuard(char* to);
-  static char* RestoreStackGuard(char* from);
-  static int ArchiveSpacePerThread();
-  static void FreeThreadResources();
-  // Sets up the default stack guard for this thread if it has not
-  // already been set up.
-  static void InitThread(const ExecutionAccess& lock);
-  // Clears the stack guard for this thread so it does not look as if
-  // it has been set up.
-  static void ClearThread(const ExecutionAccess& lock);
-  static bool IsStackOverflow();
-  static bool IsPreempted();
-  static void Preempt();
-  static bool IsInterrupted();
-  static void Interrupt();
-  static bool IsTerminateExecution();
-  static void TerminateExecution();
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  static bool IsDebugBreak();
-  static void DebugBreak();
-  static bool IsDebugCommand();
-  static void DebugCommand();
-#endif
-  static void Continue(InterruptFlag after_what);
-  // This provides an asynchronous read of the stack limits for the current
-  // thread.  There are no locks protecting this, but it is assumed that you
-  // have the global V8 lock if you are using multiple V8 threads.
-  static uintptr_t climit() {
-    return thread_local_.climit_;
-  }
-  static uintptr_t jslimit() {
-    return thread_local_.jslimit_;
-  }
-  static uintptr_t real_jslimit() {
-    return thread_local_.real_jslimit_;
-  }
-  static Address address_of_jslimit() {
-    return reinterpret_cast<Address>(&thread_local_.jslimit_);
-  }
-  static Address address_of_real_jslimit() {
-    return reinterpret_cast<Address>(&thread_local_.real_jslimit_);
-  }
- private:
-  // You should hold the ExecutionAccess lock when calling this method.
-  static bool has_pending_interrupts(const ExecutionAccess& lock) {
-    // Sanity check: We shouldn't be asking about pending interrupts
-    // unless we're not postponing them anymore.
-    ASSERT(!should_postpone_interrupts(lock));
-    return thread_local_.interrupt_flags_ != 0;
-  }
-  // You should hold the ExecutionAccess lock when calling this method.
-  static bool should_postpone_interrupts(const ExecutionAccess& lock) {
-    return thread_local_.postpone_interrupts_nesting_ > 0;
-  }
-  // You should hold the ExecutionAccess lock when calling this method.
-  static void set_interrupt_limits(const ExecutionAccess& lock) {
-    // Ignore attempts to interrupt when interrupts are postponed.
-    if (should_postpone_interrupts(lock)) return;
-    thread_local_.jslimit_ = kInterruptLimit;
-    thread_local_.climit_ = kInterruptLimit;
-    Heap::SetStackLimits();
-  }
-  // Reset limits to actual values. For example after handling interrupt.
-  // You should hold the ExecutionAccess lock when calling this method.
-  static void reset_limits(const ExecutionAccess& lock) {
-    thread_local_.jslimit_ = thread_local_.real_jslimit_;
-    thread_local_.climit_ = thread_local_.real_climit_;
-    Heap::SetStackLimits();
-  }
-  // Enable or disable interrupts.
-  static void EnableInterrupts();
-  static void DisableInterrupts();
-  static const uintptr_t kLimitSize = kPointerSize * 128 * KB;
-#ifdef V8_TARGET_ARCH_X64
-  static const uintptr_t kInterruptLimit = V8_UINT64_C(0xfffffffffffffffe);
-  static const uintptr_t kIllegalLimit = V8_UINT64_C(0xfffffffffffffff8);
-#else
-  static const uintptr_t kInterruptLimit = 0xfffffffe;
-  static const uintptr_t kIllegalLimit = 0xfffffff8;
-#endif
-  class ThreadLocal {
-   public:
-    ThreadLocal() { Clear(); }
-    // You should hold the ExecutionAccess lock when you call Initialize or
-    // Clear.
-    void Initialize();
-    void Clear();
-    // The stack limit is split into a JavaScript and a C++ stack limit. These
-    // two are the same except when running on a simulator where the C++ and
-    // JavaScript stacks are separate. Each of the two stack limits have two
-    // values. The one eith the real_ prefix is the actual stack limit
-    // set for the VM. The one without the real_ prefix has the same value as
-    // the actual stack limit except when there is an interruption (e.g. debug
-    // break or preemption) in which case it is lowered to make stack checks
-    // fail. Both the generated code and the runtime system check against the
-    // one without the real_ prefix.
-    uintptr_t real_jslimit_;  // Actual JavaScript stack limit set for the VM.
-    uintptr_t jslimit_;
-    uintptr_t real_climit_;  // Actual C++ stack limit set for the VM.
-    uintptr_t climit_;
-    int nesting_;
-    int postpone_interrupts_nesting_;
-    int interrupt_flags_;
-  };
-  static ThreadLocal thread_local_;
-  friend class StackLimitCheck;
-  friend class PostponeInterruptsScope;
-};
-// Support for checking for stack-overflows in C++ code.
-class StackLimitCheck BASE_EMBEDDED {
- public:
-  bool HasOverflowed() const {
-    // Stack has overflowed in C++ code only if stack pointer exceeds the C++
-    // stack guard and the limits are not set to interrupt values.
-    // TODO(214): Stack overflows are ignored if a interrupt is pending. This
-    // code should probably always use the initial C++ limit.
-    return (reinterpret_cast<uintptr_t>(this) < StackGuard::climit()) &&
-           StackGuard::IsStackOverflow();
-  }
-};
-// Support for temporarily postponing interrupts. When the outermost
-// postpone scope is left the interrupts will be re-enabled and any
-// interrupts that occurred while in the scope will be taken into
-// account.
-class PostponeInterruptsScope BASE_EMBEDDED {
- public:
-  PostponeInterruptsScope() {
-    StackGuard::thread_local_.postpone_interrupts_nesting_++;
-    StackGuard::DisableInterrupts();
-  }
-  ~PostponeInterruptsScope() {
-    if (--StackGuard::thread_local_.postpone_interrupts_nesting_ == 0) {
-      StackGuard::EnableInterrupts();
-    }
-  }
-};
-class GCExtension : public v8::Extension {
- public:
-  GCExtension() : v8::Extension("v8/gc", kSource) {}
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-      v8::Handle<v8::String> name);
-  static v8::Handle<v8::Value> GC(const v8::Arguments& args);
- private:
-  static const char* const kSource;
-};
-class ExternalizeStringExtension : public v8::Extension {
- public:
-  ExternalizeStringExtension() : v8::Extension("v8/externalize", kSource) {}
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-      v8::Handle<v8::String> name);
-  static v8::Handle<v8::Value> Externalize(const v8::Arguments& args);
-  static v8::Handle<v8::Value> IsAscii(const v8::Arguments& args);
- private:
-  static const char* const kSource;
-};
-} }  // namespace v8::internal
-#endif  // V8_EXECUTION_H_

data/ext/v8/upstream/build/v8/src/factory.cc DELETED Viewed

@@ -1,1003 +0,0 @@
-// 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#include "v8.h"
-#include "api.h"
-#include "debug.h"
-#include "execution.h"
-#include "factory.h"
-#include "macro-assembler.h"
-namespace v8 {
-namespace internal {
-Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag pretenure) {
-  ASSERT(0 <= size);
-  CALL_HEAP_FUNCTION(Heap::AllocateFixedArray(size, pretenure), FixedArray);
-}
-Handle<FixedArray> Factory::NewFixedArrayWithHoles(int size,
-                                                   PretenureFlag pretenure) {
-  ASSERT(0 <= size);
-  CALL_HEAP_FUNCTION(Heap::AllocateFixedArrayWithHoles(size, pretenure),
-                     FixedArray);
-}
-Handle<StringDictionary> Factory::NewStringDictionary(int at_least_space_for) {
-  ASSERT(0 <= at_least_space_for);
-  CALL_HEAP_FUNCTION(StringDictionary::Allocate(at_least_space_for),
-                     StringDictionary);
-}
-Handle<NumberDictionary> Factory::NewNumberDictionary(int at_least_space_for) {
-  ASSERT(0 <= at_least_space_for);
-  CALL_HEAP_FUNCTION(NumberDictionary::Allocate(at_least_space_for),
-                     NumberDictionary);
-}
-Handle<DescriptorArray> Factory::NewDescriptorArray(int number_of_descriptors) {
-  ASSERT(0 <= number_of_descriptors);
-  CALL_HEAP_FUNCTION(DescriptorArray::Allocate(number_of_descriptors),
-                     DescriptorArray);
-}
-// Symbols are created in the old generation (data space).
-Handle<String> Factory::LookupSymbol(Vector<const char> string) {
-  CALL_HEAP_FUNCTION(Heap::LookupSymbol(string), String);
-}
-Handle<String> Factory::NewStringFromAscii(Vector<const char> string,
-                                           PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateStringFromAscii(string, pretenure), String);
-}
-Handle<String> Factory::NewStringFromUtf8(Vector<const char> string,
-                                          PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string, pretenure), String);
-}
-Handle<String> Factory::NewStringFromTwoByte(Vector<const uc16> string,
-                                             PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateStringFromTwoByte(string, pretenure),
-                     String);
-}
-Handle<String> Factory::NewRawAsciiString(int length,
-                                          PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateRawAsciiString(length, pretenure), String);
-}
-Handle<String> Factory::NewRawTwoByteString(int length,
-                                            PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateRawTwoByteString(length, pretenure), String);
-}
-Handle<String> Factory::NewConsString(Handle<String> first,
-                                      Handle<String> second) {
-  CALL_HEAP_FUNCTION(Heap::AllocateConsString(*first, *second), String);
-}
-Handle<String> Factory::NewSubString(Handle<String> str,
-                                     int begin,
-                                     int end) {
-  CALL_HEAP_FUNCTION(str->SubString(begin, end), String);
-}
-Handle<String> Factory::NewExternalStringFromAscii(
-    ExternalAsciiString::Resource* resource) {
-  CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromAscii(resource), String);
-}
-Handle<String> Factory::NewExternalStringFromTwoByte(
-    ExternalTwoByteString::Resource* resource) {
-  CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromTwoByte(resource), String);
-}
-Handle<Context> Factory::NewGlobalContext() {
-  CALL_HEAP_FUNCTION(Heap::AllocateGlobalContext(), Context);
-}
-Handle<Context> Factory::NewFunctionContext(int length,
-                                            Handle<JSFunction> closure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateFunctionContext(length, *closure), Context);
-}
-Handle<Context> Factory::NewWithContext(Handle<Context> previous,
-                                        Handle<JSObject> extension,
-                                        bool is_catch_context) {
-  CALL_HEAP_FUNCTION(Heap::AllocateWithContext(*previous,
-                                               *extension,
-                                               is_catch_context),
-                     Context);
-}
-Handle<Struct> Factory::NewStruct(InstanceType type) {
-  CALL_HEAP_FUNCTION(Heap::AllocateStruct(type), Struct);
-}
-Handle<AccessorInfo> Factory::NewAccessorInfo() {
-  Handle<AccessorInfo> info =
-      Handle<AccessorInfo>::cast(NewStruct(ACCESSOR_INFO_TYPE));
-  info->set_flag(0);  // Must clear the flag, it was initialized as undefined.
-  return info;
-}
-Handle<Script> Factory::NewScript(Handle<String> source) {
-  // Generate id for this script.
-  int id;
-  if (Heap::last_script_id()->IsUndefined()) {
-    // Script ids start from one.
-    id = 1;
-  } else {
-    // Increment id, wrap when positive smi is exhausted.
-    id = Smi::cast(Heap::last_script_id())->value();
-    id++;
-    if (!Smi::IsValid(id)) {
-      id = 0;
-    }
-  }
-  Heap::SetLastScriptId(Smi::FromInt(id));
-  // Create and initialize script object.
-  Handle<Proxy> wrapper = Factory::NewProxy(0, TENURED);
-  Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
-  script->set_source(*source);
-  script->set_name(Heap::undefined_value());
-  script->set_id(Heap::last_script_id());
-  script->set_line_offset(Smi::FromInt(0));
-  script->set_column_offset(Smi::FromInt(0));
-  script->set_data(Heap::undefined_value());
-  script->set_context_data(Heap::undefined_value());
-  script->set_type(Smi::FromInt(Script::TYPE_NORMAL));
-  script->set_compilation_type(Smi::FromInt(Script::COMPILATION_TYPE_HOST));
-  script->set_wrapper(*wrapper);
-  script->set_line_ends(Heap::undefined_value());
-  script->set_eval_from_shared(Heap::undefined_value());
-  script->set_eval_from_instructions_offset(Smi::FromInt(0));
-  return script;
-}
-Handle<Proxy> Factory::NewProxy(Address addr, PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateProxy(addr, pretenure), Proxy);
-}
-Handle<Proxy> Factory::NewProxy(const AccessorDescriptor* desc) {
-  return NewProxy((Address) desc, TENURED);
-}
-Handle<ByteArray> Factory::NewByteArray(int length, PretenureFlag pretenure) {
-  ASSERT(0 <= length);
-  CALL_HEAP_FUNCTION(Heap::AllocateByteArray(length, pretenure), ByteArray);
-}
-Handle<PixelArray> Factory::NewPixelArray(int length,
-                                          uint8_t* external_pointer,
-                                          PretenureFlag pretenure) {
-  ASSERT(0 <= length);
-  CALL_HEAP_FUNCTION(Heap::AllocatePixelArray(length,
-                                              external_pointer,
-                                              pretenure), PixelArray);
-}
-Handle<ExternalArray> Factory::NewExternalArray(int length,
-                                                ExternalArrayType array_type,
-                                                void* external_pointer,
-                                                PretenureFlag pretenure) {
-  ASSERT(0 <= length);
-  CALL_HEAP_FUNCTION(Heap::AllocateExternalArray(length,
-                                                 array_type,
-                                                 external_pointer,
-                                                 pretenure), ExternalArray);
-}
-Handle<Map> Factory::NewMap(InstanceType type, int instance_size) {
-  CALL_HEAP_FUNCTION(Heap::AllocateMap(type, instance_size), Map);
-}
-Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
-  CALL_HEAP_FUNCTION(Heap::AllocateFunctionPrototype(*function), JSObject);
-}
-Handle<Map> Factory::CopyMapDropDescriptors(Handle<Map> src) {
-  CALL_HEAP_FUNCTION(src->CopyDropDescriptors(), Map);
-}
-Handle<Map> Factory::CopyMap(Handle<Map> src,
-                             int extra_inobject_properties) {
-  Handle<Map> copy = CopyMapDropDescriptors(src);
-  // Check that we do not overflow the instance size when adding the
-  // extra inobject properties.
-  int instance_size_delta = extra_inobject_properties * kPointerSize;
-  int max_instance_size_delta =
-      JSObject::kMaxInstanceSize - copy->instance_size();
-  if (instance_size_delta > max_instance_size_delta) {
-    // If the instance size overflows, we allocate as many properties
-    // as we can as inobject properties.
-    instance_size_delta = max_instance_size_delta;
-    extra_inobject_properties = max_instance_size_delta >> kPointerSizeLog2;
-  }
-  // Adjust the map with the extra inobject properties.
-  int inobject_properties =
-      copy->inobject_properties() + extra_inobject_properties;
-  copy->set_inobject_properties(inobject_properties);
-  copy->set_unused_property_fields(inobject_properties);
-  copy->set_instance_size(copy->instance_size() + instance_size_delta);
-  copy->set_scavenger(Heap::GetScavenger(copy->instance_type(),
-                                         copy->instance_size()));
-  return copy;
-}
-Handle<Map> Factory::CopyMapDropTransitions(Handle<Map> src) {
-  CALL_HEAP_FUNCTION(src->CopyDropTransitions(), Map);
-}
-Handle<Map> Factory::GetFastElementsMap(Handle<Map> src) {
-  CALL_HEAP_FUNCTION(src->GetFastElementsMap(), Map);
-}
-Handle<Map> Factory::GetSlowElementsMap(Handle<Map> src) {
-  CALL_HEAP_FUNCTION(src->GetSlowElementsMap(), Map);
-}
-Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
-  CALL_HEAP_FUNCTION(array->Copy(), FixedArray);
-}
-Handle<JSFunction> Factory::BaseNewFunctionFromSharedFunctionInfo(
-    Handle<SharedFunctionInfo> function_info,
-    Handle<Map> function_map,
-    PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateFunction(*function_map,
-                                            *function_info,
-                                            Heap::the_hole_value(),
-                                            pretenure),
-                     JSFunction);
-}
-Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
-    Handle<SharedFunctionInfo> function_info,
-    Handle<Context> context,
-    PretenureFlag pretenure) {
-  Handle<JSFunction> result = BaseNewFunctionFromSharedFunctionInfo(
-      function_info, Top::function_map(), pretenure);
-  result->set_context(*context);
-  int number_of_literals = function_info->num_literals();
-  Handle<FixedArray> literals =
-      Factory::NewFixedArray(number_of_literals, pretenure);
-  if (number_of_literals > 0) {
-    // Store the object, regexp and array functions in the literals
-    // array prefix.  These functions will be used when creating
-    // object, regexp and array literals in this function.
-    literals->set(JSFunction::kLiteralGlobalContextIndex,
-                  context->global_context());
-  }
-  result->set_literals(*literals);
-  return result;
-}
-Handle<Object> Factory::NewNumber(double value,
-                                  PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::NumberFromDouble(value, pretenure), Object);
-}
-Handle<Object> Factory::NewNumberFromInt(int value) {
-  CALL_HEAP_FUNCTION(Heap::NumberFromInt32(value), Object);
-}
-Handle<Object> Factory::NewNumberFromUint(uint32_t value) {
-  CALL_HEAP_FUNCTION(Heap::NumberFromUint32(value), Object);
-}
-Handle<JSObject> Factory::NewNeanderObject() {
-  CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(Heap::neander_map()),
-                     JSObject);
-}
-Handle<Object> Factory::NewTypeError(const char* type,
-                                     Vector< Handle<Object> > args) {
-  return NewError("MakeTypeError", type, args);
-}
-Handle<Object> Factory::NewTypeError(Handle<String> message) {
-  return NewError("$TypeError", message);
-}
-Handle<Object> Factory::NewRangeError(const char* type,
-                                      Vector< Handle<Object> > args) {
-  return NewError("MakeRangeError", type, args);
-}
-Handle<Object> Factory::NewRangeError(Handle<String> message) {
-  return NewError("$RangeError", message);
-}
-Handle<Object> Factory::NewSyntaxError(const char* type, Handle<JSArray> args) {
-  return NewError("MakeSyntaxError", type, args);
-}
-Handle<Object> Factory::NewSyntaxError(Handle<String> message) {
-  return NewError("$SyntaxError", message);
-}
-Handle<Object> Factory::NewReferenceError(const char* type,
-                                          Vector< Handle<Object> > args) {
-  return NewError("MakeReferenceError", type, args);
-}
-Handle<Object> Factory::NewReferenceError(Handle<String> message) {
-  return NewError("$ReferenceError", message);
-}
-Handle<Object> Factory::NewError(const char* maker, const char* type,
-    Vector< Handle<Object> > args) {
-  v8::HandleScope scope;  // Instantiate a closeable HandleScope for EscapeFrom.
-  Handle<FixedArray> array = Factory::NewFixedArray(args.length());
-  for (int i = 0; i < args.length(); i++) {
-    array->set(i, *args[i]);
-  }
-  Handle<JSArray> object = Factory::NewJSArrayWithElements(array);
-  Handle<Object> result = NewError(maker, type, object);
-  return result.EscapeFrom(&scope);
-}
-Handle<Object> Factory::NewEvalError(const char* type,
-                                     Vector< Handle<Object> > args) {
-  return NewError("MakeEvalError", type, args);
-}
-Handle<Object> Factory::NewError(const char* type,
-                                 Vector< Handle<Object> > args) {
-  return NewError("MakeError", type, args);
-}
-Handle<Object> Factory::NewError(const char* maker,
-                                 const char* type,
-                                 Handle<JSArray> args) {
-  Handle<String> make_str = Factory::LookupAsciiSymbol(maker);
-  Handle<Object> fun_obj(Top::builtins()->GetProperty(*make_str));
-  // If the builtins haven't been properly configured yet this error
-  // constructor may not have been defined.  Bail out.
-  if (!fun_obj->IsJSFunction())
-    return Factory::undefined_value();
-  Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
-  Handle<Object> type_obj = Factory::LookupAsciiSymbol(type);
-  Object** argv[2] = { type_obj.location(),
-                       Handle<Object>::cast(args).location() };
-  // Invoke the JavaScript factory method. If an exception is thrown while
-  // running the factory method, use the exception as the result.
-  bool caught_exception;
-  Handle<Object> result = Execution::TryCall(fun,
-                                             Top::builtins(),
-                                             2,
-                                             argv,
-                                             &caught_exception);
-  return result;
-}
-Handle<Object> Factory::NewError(Handle<String> message) {
-  return NewError("$Error", message);
-}
-Handle<Object> Factory::NewError(const char* constructor,
-                                 Handle<String> message) {
-  Handle<String> constr = Factory::LookupAsciiSymbol(constructor);
-  Handle<JSFunction> fun =
-      Handle<JSFunction>(
-          JSFunction::cast(
-              Top::builtins()->GetProperty(*constr)));
-  Object** argv[1] = { Handle<Object>::cast(message).location() };
-  // Invoke the JavaScript factory method. If an exception is thrown while
-  // running the factory method, use the exception as the result.
-  bool caught_exception;
-  Handle<Object> result = Execution::TryCall(fun,
-                                             Top::builtins(),
-                                             1,
-                                             argv,
-                                             &caught_exception);
-  return result;
-}
-Handle<JSFunction> Factory::NewFunction(Handle<String> name,
-                                        InstanceType type,
-                                        int instance_size,
-                                        Handle<Code> code,
-                                        bool force_initial_map) {
-  // Allocate the function
-  Handle<JSFunction> function = NewFunction(name, the_hole_value());
-  function->set_code(*code);
-  if (force_initial_map ||
-      type != JS_OBJECT_TYPE ||
-      instance_size != JSObject::kHeaderSize) {
-    Handle<Map> initial_map = NewMap(type, instance_size);
-    Handle<JSObject> prototype = NewFunctionPrototype(function);
-    initial_map->set_prototype(*prototype);
-    function->set_initial_map(*initial_map);
-    initial_map->set_constructor(*function);
-  } else {
-    ASSERT(!function->has_initial_map());
-    ASSERT(!function->has_prototype());
-  }
-  return function;
-}
-Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name,
-                                                     InstanceType type,
-                                                     int instance_size,
-                                                     Handle<JSObject> prototype,
-                                                     Handle<Code> code,
-                                                     bool force_initial_map) {
-  // Allocate the function
-  Handle<JSFunction> function = NewFunction(name, prototype);
-  function->set_code(*code);
-  if (force_initial_map ||
-      type != JS_OBJECT_TYPE ||
-      instance_size != JSObject::kHeaderSize) {
-    Handle<Map> initial_map = NewMap(type, instance_size);
-    function->set_initial_map(*initial_map);
-    initial_map->set_constructor(*function);
-  }
-  // Set function.prototype and give the prototype a constructor
-  // property that refers to the function.
-  SetPrototypeProperty(function, prototype);
-  SetProperty(prototype, Factory::constructor_symbol(), function, DONT_ENUM);
-  return function;
-}
-Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
-                                                        Handle<Code> code) {
-  Handle<JSFunction> function = NewFunctionWithoutPrototype(name);
-  function->set_code(*code);
-  ASSERT(!function->has_initial_map());
-  ASSERT(!function->has_prototype());
-  return function;
-}
-Handle<Code> Factory::NewCode(const CodeDesc& desc,
-                              Code::Flags flags,
-                              Handle<Object> self_ref) {
-  CALL_HEAP_FUNCTION(Heap::CreateCode(desc, flags, self_ref), Code);
-}
-Handle<Code> Factory::CopyCode(Handle<Code> code) {
-  CALL_HEAP_FUNCTION(Heap::CopyCode(*code), Code);
-}
-Handle<Code> Factory::CopyCode(Handle<Code> code, Vector<byte> reloc_info) {
-  CALL_HEAP_FUNCTION(Heap::CopyCode(*code, reloc_info), Code);
-}
-static inline Object* DoCopyInsert(DescriptorArray* array,
-                                   String* key,
-                                   Object* value,
-                                   PropertyAttributes attributes) {
-  CallbacksDescriptor desc(key, value, attributes);
-  Object* obj = array->CopyInsert(&desc, REMOVE_TRANSITIONS);
-  return obj;
-}
-// Allocate the new array.
-Handle<DescriptorArray> Factory::CopyAppendProxyDescriptor(
-    Handle<DescriptorArray> array,
-    Handle<String> key,
-    Handle<Object> value,
-    PropertyAttributes attributes) {
-  CALL_HEAP_FUNCTION(DoCopyInsert(*array, *key, *value, attributes),
-                     DescriptorArray);
-}
-Handle<String> Factory::SymbolFromString(Handle<String> value) {
-  CALL_HEAP_FUNCTION(Heap::LookupSymbol(*value), String);
-}
-Handle<DescriptorArray> Factory::CopyAppendCallbackDescriptors(
-    Handle<DescriptorArray> array,
-    Handle<Object> descriptors) {
-  v8::NeanderArray callbacks(descriptors);
-  int nof_callbacks = callbacks.length();
-  Handle<DescriptorArray> result =
-      NewDescriptorArray(array->number_of_descriptors() + nof_callbacks);
-  // Number of descriptors added to the result so far.
-  int descriptor_count = 0;
-  // Copy the descriptors from the array.
-  for (int i = 0; i < array->number_of_descriptors(); i++) {
-    if (array->GetType(i) != NULL_DESCRIPTOR) {
-      result->CopyFrom(descriptor_count++, *array, i);
-    }
-  }
-  // Number of duplicates detected.
-  int duplicates = 0;
-  // Fill in new callback descriptors.  Process the callbacks from
-  // back to front so that the last callback with a given name takes
-  // precedence over previously added callbacks with that name.
-  for (int i = nof_callbacks - 1; i >= 0; i--) {
-    Handle<AccessorInfo> entry =
-        Handle<AccessorInfo>(AccessorInfo::cast(callbacks.get(i)));
-    // Ensure the key is a symbol before writing into the instance descriptor.
-    Handle<String> key =
-        SymbolFromString(Handle<String>(String::cast(entry->name())));
-    // Check if a descriptor with this name already exists before writing.
-    if (result->LinearSearch(*key, descriptor_count) ==
-        DescriptorArray::kNotFound) {
-      CallbacksDescriptor desc(*key, *entry, entry->property_attributes());
-      result->Set(descriptor_count, &desc);
-      descriptor_count++;
-    } else {
-      duplicates++;
-    }
-  }
-  // If duplicates were detected, allocate a result of the right size
-  // and transfer the elements.
-  if (duplicates > 0) {
-    int number_of_descriptors = result->number_of_descriptors() - duplicates;
-    Handle<DescriptorArray> new_result =
-        NewDescriptorArray(number_of_descriptors);
-    for (int i = 0; i < number_of_descriptors; i++) {
-      new_result->CopyFrom(i, *result, i);
-    }
-    result = new_result;
-  }
-  // Sort the result before returning.
-  result->Sort();
-  return result;
-}
-Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
-                                      PretenureFlag pretenure) {
-  CALL_HEAP_FUNCTION(Heap::AllocateJSObject(*constructor, pretenure), JSObject);
-}
-Handle<GlobalObject> Factory::NewGlobalObject(
-    Handle<JSFunction> constructor) {
-  CALL_HEAP_FUNCTION(Heap::AllocateGlobalObject(*constructor),
-                     GlobalObject);
-}
-Handle<JSObject> Factory::NewJSObjectFromMap(Handle<Map> map) {
-  CALL_HEAP_FUNCTION(Heap::AllocateJSObjectFromMap(*map, NOT_TENURED),
-                     JSObject);
-}
-Handle<JSArray> Factory::NewJSArray(int length,
-                                    PretenureFlag pretenure) {
-  Handle<JSObject> obj = NewJSObject(Top::array_function(), pretenure);
-  CALL_HEAP_FUNCTION(Handle<JSArray>::cast(obj)->Initialize(length), JSArray);
-}
-Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArray> elements,
-                                                PretenureFlag pretenure) {
-  Handle<JSArray> result =
-      Handle<JSArray>::cast(NewJSObject(Top::array_function(), pretenure));
-  result->SetContent(*elements);
-  return result;
-}
-Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
-    Handle<String> name,
-    int number_of_literals,
-    Handle<Code> code,
-    Handle<SerializedScopeInfo> scope_info) {
-  Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name);
-  shared->set_code(*code);
-  shared->set_scope_info(*scope_info);
-  int literals_array_size = number_of_literals;
-  // If the function contains object, regexp or array literals,
-  // allocate extra space for a literals array prefix containing the
-  // context.
-  if (number_of_literals > 0) {
-    literals_array_size += JSFunction::kLiteralsPrefixSize;
-  }
-  shared->set_num_literals(literals_array_size);
-  return shared;
-}
-Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(Handle<String> name) {
-  CALL_HEAP_FUNCTION(Heap::AllocateSharedFunctionInfo(*name),
-                     SharedFunctionInfo);
-}
-Handle<String> Factory::NumberToString(Handle<Object> number) {
-  CALL_HEAP_FUNCTION(Heap::NumberToString(*number), String);
-}
-Handle<NumberDictionary> Factory::DictionaryAtNumberPut(
-    Handle<NumberDictionary> dictionary,
-    uint32_t key,
-    Handle<Object> value) {
-  CALL_HEAP_FUNCTION(dictionary->AtNumberPut(key, *value), NumberDictionary);
-}
-Handle<JSFunction> Factory::NewFunctionHelper(Handle<String> name,
-                                              Handle<Object> prototype) {
-  Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
-  CALL_HEAP_FUNCTION(Heap::AllocateFunction(*Top::function_map(),
-                                            *function_share,
-                                            *prototype),
-                     JSFunction);
-}
-Handle<JSFunction> Factory::NewFunction(Handle<String> name,
-                                        Handle<Object> prototype) {
-  Handle<JSFunction> fun = NewFunctionHelper(name, prototype);
-  fun->set_context(Top::context()->global_context());
-  return fun;
-}
-Handle<JSFunction> Factory::NewFunctionWithoutPrototypeHelper(
-    Handle<String> name) {
-  Handle<SharedFunctionInfo> function_share = NewSharedFunctionInfo(name);
-  CALL_HEAP_FUNCTION(Heap::AllocateFunction(
-                         *Top::function_without_prototype_map(),
-                         *function_share,
-                         *the_hole_value()),
-                     JSFunction);
-}
-Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name) {
-  Handle<JSFunction> fun = NewFunctionWithoutPrototypeHelper(name);
-  fun->set_context(Top::context()->global_context());
-  return fun;
-}
-Handle<Object> Factory::ToObject(Handle<Object> object) {
-  CALL_HEAP_FUNCTION(object->ToObject(), Object);
-}
-Handle<Object> Factory::ToObject(Handle<Object> object,
-                                 Handle<Context> global_context) {
-  CALL_HEAP_FUNCTION(object->ToObject(*global_context), Object);
-}
-#ifdef ENABLE_DEBUGGER_SUPPORT
-Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
-  // Get the original code of the function.
-  Handle<Code> code(shared->code());
-  // Create a copy of the code before allocating the debug info object to avoid
-  // allocation while setting up the debug info object.
-  Handle<Code> original_code(*Factory::CopyCode(code));
-  // Allocate initial fixed array for active break points before allocating the
-  // debug info object to avoid allocation while setting up the debug info
-  // object.
-  Handle<FixedArray> break_points(
-      Factory::NewFixedArray(Debug::kEstimatedNofBreakPointsInFunction));
-  // Create and set up the debug info object. Debug info contains function, a
-  // copy of the original code, the executing code and initial fixed array for
-  // active break points.
-  Handle<DebugInfo> debug_info =
-      Handle<DebugInfo>::cast(Factory::NewStruct(DEBUG_INFO_TYPE));
-  debug_info->set_shared(*shared);
-  debug_info->set_original_code(*original_code);
-  debug_info->set_code(*code);
-  debug_info->set_break_points(*break_points);
-  // Link debug info to function.
-  shared->set_debug_info(*debug_info);
-  return debug_info;
-}
-#endif
-Handle<JSObject> Factory::NewArgumentsObject(Handle<Object> callee,
-                                             int length) {
-  CALL_HEAP_FUNCTION(Heap::AllocateArgumentsObject(*callee, length), JSObject);
-}
-Handle<JSFunction> Factory::CreateApiFunction(
-    Handle<FunctionTemplateInfo> obj, ApiInstanceType instance_type) {
-  Handle<Code> code = Handle<Code>(Builtins::builtin(Builtins::HandleApiCall));
-  Handle<Code> construct_stub =
-      Handle<Code>(Builtins::builtin(Builtins::JSConstructStubApi));
-  int internal_field_count = 0;
-  if (!obj->instance_template()->IsUndefined()) {
-    Handle<ObjectTemplateInfo> instance_template =
-        Handle<ObjectTemplateInfo>(
-            ObjectTemplateInfo::cast(obj->instance_template()));
-    internal_field_count =
-        Smi::cast(instance_template->internal_field_count())->value();
-  }
-  int instance_size = kPointerSize * internal_field_count;
-  InstanceType type = INVALID_TYPE;
-  switch (instance_type) {
-    case JavaScriptObject:
-      type = JS_OBJECT_TYPE;
-      instance_size += JSObject::kHeaderSize;
-      break;
-    case InnerGlobalObject:
-      type = JS_GLOBAL_OBJECT_TYPE;
-      instance_size += JSGlobalObject::kSize;
-      break;
-    case OuterGlobalObject:
-      type = JS_GLOBAL_PROXY_TYPE;
-      instance_size += JSGlobalProxy::kSize;
-      break;
-    default:
-      break;
-  }
-  ASSERT(type != INVALID_TYPE);
-  Handle<JSFunction> result =
-      Factory::NewFunction(Factory::empty_symbol(),
-                           type,
-                           instance_size,
-                           code,
-                           true);
-  // Set class name.
-  Handle<Object> class_name = Handle<Object>(obj->class_name());
-  if (class_name->IsString()) {
-    result->shared()->set_instance_class_name(*class_name);
-    result->shared()->set_name(*class_name);
-  }
-  Handle<Map> map = Handle<Map>(result->initial_map());
-  // Mark as undetectable if needed.
-  if (obj->undetectable()) {
-    map->set_is_undetectable();
-  }
-  // Mark as hidden for the __proto__ accessor if needed.
-  if (obj->hidden_prototype()) {
-    map->set_is_hidden_prototype();
-  }
-  // Mark as needs_access_check if needed.
-  if (obj->needs_access_check()) {
-    map->set_is_access_check_needed(true);
-  }
-  // Set interceptor information in the map.
-  if (!obj->named_property_handler()->IsUndefined()) {
-    map->set_has_named_interceptor();
-  }
-  if (!obj->indexed_property_handler()->IsUndefined()) {
-    map->set_has_indexed_interceptor();
-  }
-  // Set instance call-as-function information in the map.
-  if (!obj->instance_call_handler()->IsUndefined()) {
-    map->set_has_instance_call_handler();
-  }
-  result->shared()->set_function_data(*obj);
-  result->shared()->set_construct_stub(*construct_stub);
-  result->shared()->DontAdaptArguments();
-  // Recursively copy parent templates' accessors, 'data' may be modified.
-  Handle<DescriptorArray> array =
-      Handle<DescriptorArray>(map->instance_descriptors());
-  while (true) {
-    Handle<Object> props = Handle<Object>(obj->property_accessors());
-    if (!props->IsUndefined()) {
-      array = Factory::CopyAppendCallbackDescriptors(array, props);
-    }
-    Handle<Object> parent = Handle<Object>(obj->parent_template());
-    if (parent->IsUndefined()) break;
-    obj = Handle<FunctionTemplateInfo>::cast(parent);
-  }
-  if (!array->IsEmpty()) {
-    map->set_instance_descriptors(*array);
-  }
-  ASSERT(result->shared()->IsApiFunction());
-  return result;
-}
-Handle<MapCache> Factory::NewMapCache(int at_least_space_for) {
-  CALL_HEAP_FUNCTION(MapCache::Allocate(at_least_space_for), MapCache);
-}
-static Object* UpdateMapCacheWith(Context* context,
-                                  FixedArray* keys,
-                                  Map* map) {
-  Object* result = MapCache::cast(context->map_cache())->Put(keys, map);
-  if (!result->IsFailure()) context->set_map_cache(MapCache::cast(result));
-  return result;
-}
-Handle<MapCache> Factory::AddToMapCache(Handle<Context> context,
-                                        Handle<FixedArray> keys,
-                                        Handle<Map> map) {
-  CALL_HEAP_FUNCTION(UpdateMapCacheWith(*context, *keys, *map), MapCache);
-}
-Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
-                                               Handle<FixedArray> keys) {
-  if (context->map_cache()->IsUndefined()) {
-    // Allocate the new map cache for the global context.
-    Handle<MapCache> new_cache = NewMapCache(24);
-    context->set_map_cache(*new_cache);
-  }
-  // Check to see whether there is a matching element in the cache.
-  Handle<MapCache> cache =
-      Handle<MapCache>(MapCache::cast(context->map_cache()));
-  Handle<Object> result = Handle<Object>(cache->Lookup(*keys));
-  if (result->IsMap()) return Handle<Map>::cast(result);
-  // Create a new map and add it to the cache.
-  Handle<Map> map =
-      CopyMap(Handle<Map>(context->object_function()->initial_map()),
-              keys->length());
-  AddToMapCache(context, keys, map);
-  return Handle<Map>(map);
-}
-void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
-                                JSRegExp::Type type,
-                                Handle<String> source,
-                                JSRegExp::Flags flags,
-                                Handle<Object> data) {
-  Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
-  store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
-  store->set(JSRegExp::kSourceIndex, *source);
-  store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
-  store->set(JSRegExp::kAtomPatternIndex, *data);
-  regexp->set_data(*store);
-}
-void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
-                                    JSRegExp::Type type,
-                                    Handle<String> source,
-                                    JSRegExp::Flags flags,
-                                    int capture_count) {
-  Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
-  store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
-  store->set(JSRegExp::kSourceIndex, *source);
-  store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
-  store->set(JSRegExp::kIrregexpASCIICodeIndex, Heap::the_hole_value());
-  store->set(JSRegExp::kIrregexpUC16CodeIndex, Heap::the_hole_value());
-  store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
-  store->set(JSRegExp::kIrregexpCaptureCountIndex,
-             Smi::FromInt(capture_count));
-  regexp->set_data(*store);
-}
-void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc,
-                                Handle<JSObject> instance,
-                                bool* pending_exception) {
-  // Configure the instance by adding the properties specified by the
-  // instance template.
-  Handle<Object> instance_template = Handle<Object>(desc->instance_template());
-  if (!instance_template->IsUndefined()) {
-    Execution::ConfigureInstance(instance,
-                                 instance_template,
-                                 pending_exception);
-  } else {
-    *pending_exception = false;
-  }
-}
-} }  // namespace v8::internal