therubyracer 0.9.0beta2 → 0.9.0beta3

data/ext/v8/upstream/3.1.8/src/disasm.h

@@ -1,77 +0,0 @@
-// Copyright 2007-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_DISASM_H_
-#define V8_DISASM_H_
-
-namespace disasm {
-
-typedef unsigned char byte;
-
-// Interface and default implementation for converting addresses and
-// register-numbers to text.  The default implementation is machine
-// specific.
-class NameConverter {
- public:
-  virtual ~NameConverter() {}
-  virtual const char* NameOfCPURegister(int reg) const;
-  virtual const char* NameOfByteCPURegister(int reg) const;
-  virtual const char* NameOfXMMRegister(int reg) const;
-  virtual const char* NameOfAddress(byte* addr) const;
-  virtual const char* NameOfConstant(byte* addr) const;
-  virtual const char* NameInCode(byte* addr) const;
-};
-
-
-// A generic Disassembler interface
-class Disassembler {
- public:
-  // Caller deallocates converter.
-  explicit Disassembler(const NameConverter& converter);
-
-  virtual ~Disassembler();
-
-  // Writes one disassembled instruction into 'buffer' (0-terminated).
-  // Returns the length of the disassembled machine instruction in bytes.
-  int InstructionDecode(v8::internal::Vector<char> buffer, byte* instruction);
-
-  // Returns -1 if instruction does not mark the beginning of a constant pool,
-  // or the number of entries in the constant pool beginning here.
-  int ConstantPoolSizeAt(byte* instruction);
-
-  // Write disassembly into specified file 'f' using specified NameConverter
-  // (see constructor).
-  static void Disassemble(FILE* f, byte* begin, byte* end);
- private:
-  const NameConverter& converter_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(Disassembler);
-};
-
-}  // namespace disasm
-
-#endif  // V8_DISASM_H_

data/ext/v8/upstream/3.1.8/src/disassembler.cc

@@ -1,338 +0,0 @@
-// 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
-//       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 "code-stubs.h"
-#include "codegen-inl.h"
-#include "debug.h"
-#include "deoptimizer.h"
-#include "disasm.h"
-#include "disassembler.h"
-#include "macro-assembler.h"
-#include "serialize.h"
-#include "string-stream.h"
-
-namespace v8 {
-namespace internal {
-
-#ifdef ENABLE_DISASSEMBLER
-
-void Disassembler::Dump(FILE* f, byte* begin, byte* end) {
-  for (byte* pc = begin; pc < end; pc++) {
-    if (f == NULL) {
-      PrintF("%" V8PRIxPTR "  %4" V8PRIdPTR "  %02x\n",
-             reinterpret_cast<intptr_t>(pc),
-             pc - begin,
-             *pc);
-    } else {
-      fprintf(f, "%" V8PRIxPTR "  %4" V8PRIdPTR "  %02x\n",
-              reinterpret_cast<uintptr_t>(pc), pc - begin, *pc);
-    }
-  }
-}
-
-
-class V8NameConverter: public disasm::NameConverter {
- public:
-  explicit V8NameConverter(Code* code) : code_(code) {}
-  virtual const char* NameOfAddress(byte* pc) const;
-  virtual const char* NameInCode(byte* addr) const;
-  Code* code() const { return code_; }
- private:
-  Code* code_;
-};
-
-
-const char* V8NameConverter::NameOfAddress(byte* pc) const {
-  static v8::internal::EmbeddedVector<char, 128> buffer;
-
-  const char* name = Builtins::Lookup(pc);
-  if (name != NULL) {
-    OS::SNPrintF(buffer, "%s  (%p)", name, pc);
-    return buffer.start();
-  }
-
-  if (code_ != NULL) {
-    int offs = static_cast<int>(pc - code_->instruction_start());
-    // print as code offset, if it seems reasonable
-    if (0 <= offs && offs < code_->instruction_size()) {
-      OS::SNPrintF(buffer, "%d  (%p)", offs, pc);
-      return buffer.start();
-    }
-  }
-
-  return disasm::NameConverter::NameOfAddress(pc);
-}
-
-
-const char* V8NameConverter::NameInCode(byte* addr) const {
-  // The V8NameConverter is used for well known code, so we can "safely"
-  // dereference pointers in generated code.
-  return (code_ != NULL) ? reinterpret_cast<const char*>(addr) : "";
-}
-
-
-static void DumpBuffer(FILE* f, char* buff) {
-  if (f == NULL) {
-    PrintF("%s", buff);
-  } else {
-    fprintf(f, "%s", buff);
-  }
-}
-
-static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
-static const int kRelocInfoPosition = 57;
-
-static int DecodeIt(FILE* f,
-                    const V8NameConverter& converter,
-                    byte* begin,
-                    byte* end) {
-  NoHandleAllocation ha;
-  AssertNoAllocation no_alloc;
-  ExternalReferenceEncoder ref_encoder;
-
-  v8::internal::EmbeddedVector<char, 128> decode_buffer;
-  v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
-  byte* pc = begin;
-  disasm::Disassembler d(converter);
-  RelocIterator* it = NULL;
-  if (converter.code() != NULL) {
-    it = new RelocIterator(converter.code());
-  } else {
-    // No relocation information when printing code stubs.
-  }
-  int constants = -1;  // no constants being decoded at the start
-
-  while (pc < end) {
-    // First decode instruction so that we know its length.
-    byte* prev_pc = pc;
-    if (constants > 0) {
-      OS::SNPrintF(decode_buffer,
-                   "%08x       constant",
-                   *reinterpret_cast<int32_t*>(pc));
-      constants--;
-      pc += 4;
-    } else {
-      int num_const = d.ConstantPoolSizeAt(pc);
-      if (num_const >= 0) {
-        OS::SNPrintF(decode_buffer,
-                     "%08x       constant pool begin",
-                     *reinterpret_cast<int32_t*>(pc));
-        constants = num_const;
-        pc += 4;
-      } else if (it != NULL && !it->done() && it->rinfo()->pc() == pc &&
-          it->rinfo()->rmode() == RelocInfo::INTERNAL_REFERENCE) {
-        // raw pointer embedded in code stream, e.g., jump table
-        byte* ptr = *reinterpret_cast<byte**>(pc);
-        OS::SNPrintF(decode_buffer,
-                     "%08" V8PRIxPTR "      jump table entry %4" V8PRIdPTR,
-                     ptr,
-                     ptr - begin);
-        pc += 4;
-      } else {
-        decode_buffer[0] = '\0';
-        pc += d.InstructionDecode(decode_buffer, pc);
-      }
-    }
-
-    // Collect RelocInfo for this instruction (prev_pc .. pc-1)
-    List<const char*> comments(4);
-    List<byte*> pcs(1);
-    List<RelocInfo::Mode> rmodes(1);
-    List<intptr_t> datas(1);
-    if (it != NULL) {
-      while (!it->done() && it->rinfo()->pc() < pc) {
-        if (RelocInfo::IsComment(it->rinfo()->rmode())) {
-          // For comments just collect the text.
-          comments.Add(reinterpret_cast<const char*>(it->rinfo()->data()));
-        } else {
-          // For other reloc info collect all data.
-          pcs.Add(it->rinfo()->pc());
-          rmodes.Add(it->rinfo()->rmode());
-          datas.Add(it->rinfo()->data());
-        }
-        it->next();
-      }
-    }
-
-    StringBuilder out(out_buffer.start(), out_buffer.length());
-
-    // Comments.
-    for (int i = 0; i < comments.length(); i++) {
-      out.AddFormatted("                  %s\n", comments[i]);
-    }
-
-    // Write out comments, resets outp so that we can format the next line.
-    DumpBuffer(f, out.Finalize());
-    out.Reset();
-
-    // Instruction address and instruction offset.
-    out.AddFormatted("%p  %4d  ", prev_pc, prev_pc - begin);
-
-    // Instruction.
-    out.AddFormatted("%s", decode_buffer.start());
-
-    // Print all the reloc info for this instruction which are not comments.
-    for (int i = 0; i < pcs.length(); i++) {
-      // Put together the reloc info
-      RelocInfo relocinfo(pcs[i], rmodes[i], datas[i]);
-
-      // Indent the printing of the reloc info.
-      if (i == 0) {
-        // The first reloc info is printed after the disassembled instruction.
-        out.AddPadding(' ', kRelocInfoPosition - out.position());
-      } else {
-        // Additional reloc infos are printed on separate lines.
-        out.AddFormatted("\n");
-        out.AddPadding(' ', kRelocInfoPosition);
-      }
-
-      RelocInfo::Mode rmode = relocinfo.rmode();
-      if (RelocInfo::IsPosition(rmode)) {
-        if (RelocInfo::IsStatementPosition(rmode)) {
-          out.AddFormatted("    ;; debug: statement %d", relocinfo.data());
-        } else {
-          out.AddFormatted("    ;; debug: position %d", relocinfo.data());
-        }
-      } else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
-        HeapStringAllocator allocator;
-        StringStream accumulator(&allocator);
-        relocinfo.target_object()->ShortPrint(&accumulator);
-        SmartPointer<const char> obj_name = accumulator.ToCString();
-        out.AddFormatted("    ;; object: %s", *obj_name);
-      } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
-        const char* reference_name =
-            ref_encoder.NameOfAddress(*relocinfo.target_reference_address());
-        out.AddFormatted("    ;; external reference (%s)", reference_name);
-      } else if (RelocInfo::IsCodeTarget(rmode)) {
-        out.AddFormatted("    ;; code:");
-        if (rmode == RelocInfo::CONSTRUCT_CALL) {
-          out.AddFormatted(" constructor,");
-        }
-        Code* code = Code::GetCodeFromTargetAddress(relocinfo.target_address());
-        Code::Kind kind = code->kind();
-        if (code->is_inline_cache_stub()) {
-          if (rmode == RelocInfo::CODE_TARGET_CONTEXT) {
-            out.AddFormatted(" contextual,");
-          }
-          InlineCacheState ic_state = code->ic_state();
-          out.AddFormatted(" %s, %s", Code::Kind2String(kind),
-              Code::ICState2String(ic_state));
-          if (ic_state == MONOMORPHIC) {
-            PropertyType type = code->type();
-            out.AddFormatted(", %s", Code::PropertyType2String(type));
-          }
-          if (code->ic_in_loop() == IN_LOOP) {
-            out.AddFormatted(", in_loop");
-          }
-          if (kind == Code::CALL_IC || kind == Code::KEYED_CALL_IC) {
-            out.AddFormatted(", argc = %d", code->arguments_count());
-          }
-        } else if (kind == Code::STUB) {
-          // Reverse lookup required as the minor key cannot be retrieved
-          // from the code object.
-          Object* obj = Heap::code_stubs()->SlowReverseLookup(code);
-          if (obj != Heap::undefined_value()) {
-            ASSERT(obj->IsSmi());
-            // Get the STUB key and extract major and minor key.
-            uint32_t key = Smi::cast(obj)->value();
-            uint32_t minor_key = CodeStub::MinorKeyFromKey(key);
-            CodeStub::Major major_key = CodeStub::GetMajorKey(code);
-            ASSERT(major_key == CodeStub::MajorKeyFromKey(key));
-            out.AddFormatted(" %s, %s, ",
-                             Code::Kind2String(kind),
-                             CodeStub::MajorName(major_key, false));
-            switch (major_key) {
-              case CodeStub::CallFunction: {
-                int argc =
-                    CallFunctionStub::ExtractArgcFromMinorKey(minor_key);
-                out.AddFormatted("argc = %d", argc);
-                break;
-              }
-              default:
-                out.AddFormatted("minor: %d", minor_key);
-            }
-          }
-        } else {
-          out.AddFormatted(" %s", Code::Kind2String(kind));
-        }
-      } else if (rmode == RelocInfo::RUNTIME_ENTRY) {
-        // A runtime entry reloinfo might be a deoptimization bailout.
-        Address addr = relocinfo.target_address();
-        int id = Deoptimizer::GetDeoptimizationId(addr, Deoptimizer::EAGER);
-        if (id == Deoptimizer::kNotDeoptimizationEntry) {
-          out.AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
-        } else {
-          out.AddFormatted("    ;; deoptimization bailout %d", id);
-        }
-      } else {
-        out.AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
-      }
-    }
-    out.AddString("\n");
-    DumpBuffer(f, out.Finalize());
-    out.Reset();
-  }
-
-  delete it;
-  return static_cast<int>(pc - begin);
-}
-
-
-int Disassembler::Decode(FILE* f, byte* begin, byte* end) {
-  V8NameConverter defaultConverter(NULL);
-  return DecodeIt(f, defaultConverter, begin, end);
-}
-
-
-// Called by Code::CodePrint.
-void Disassembler::Decode(FILE* f, Code* code) {
-  int decode_size = (code->kind() == Code::OPTIMIZED_FUNCTION)
-      ? static_cast<int>(code->safepoint_table_offset())
-      : code->instruction_size();
-  // If there might be a stack check table, stop before reaching it.
-  if (code->kind() == Code::FUNCTION) {
-    decode_size =
-        Min(decode_size, static_cast<int>(code->stack_check_table_offset()));
-  }
-
-  byte* begin = code->instruction_start();
-  byte* end = begin + decode_size;
-  V8NameConverter v8NameConverter(code);
-  DecodeIt(f, v8NameConverter, begin, end);
-}
-
-#else  // ENABLE_DISASSEMBLER
-
-void Disassembler::Dump(FILE* f, byte* begin, byte* end) {}
-int Disassembler::Decode(FILE* f, byte* begin, byte* end) { return 0; }
-void Disassembler::Decode(FILE* f, Code* code) {}
-
-#endif  // ENABLE_DISASSEMBLER
-
-} }  // namespace v8::internal

data/ext/v8/upstream/3.1.8/src/execution.cc

@@ -1,735 +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 <stdlib.h>
-
-#include "v8.h"
-
-#include "api.h"
-#include "bootstrapper.h"
-#include "codegen-inl.h"
-#include "debug.h"
-#include "runtime-profiler.h"
-#include "simulator.h"
-#include "v8threads.h"
-#include "vm-state-inl.h"
-
-namespace v8 {
-namespace internal {
-
-
-static Handle<Object> Invoke(bool construct,
-                             Handle<JSFunction> func,
-                             Handle<Object> receiver,
-                             int argc,
-                             Object*** args,
-                             bool* has_pending_exception) {
-  // Entering JavaScript.
-  VMState state(JS);
-
-  // Placeholder for return value.
-  MaybeObject* value = reinterpret_cast<Object*>(kZapValue);
-
-  typedef Object* (*JSEntryFunction)(
-    byte* entry,
-    Object* function,
-    Object* receiver,
-    int argc,
-    Object*** args);
-
-  Handle<Code> code;
-  if (construct) {
-    JSConstructEntryStub stub;
-    code = stub.GetCode();
-  } else {
-    JSEntryStub stub;
-    code = stub.GetCode();
-  }
-
-  // Convert calls on global objects to be calls on the global
-  // receiver instead to avoid having a 'this' pointer which refers
-  // directly to a global object.
-  if (receiver->IsGlobalObject()) {
-    Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
-    receiver = Handle<JSObject>(global->global_receiver());
-  }
-
-  // Make sure that the global object of the context we're about to
-  // make the current one is indeed a global object.
-  ASSERT(func->context()->global()->IsGlobalObject());
-
-  {
-    // Save and restore context around invocation and block the
-    // allocation of handles without explicit handle scopes.
-    SaveContext save;
-    NoHandleAllocation na;
-    JSEntryFunction entry = FUNCTION_CAST<JSEntryFunction>(code->entry());
-
-    // Call the function through the right JS entry stub.
-    byte* entry_address = func->code()->entry();
-    JSFunction* function = *func;
-    Object* receiver_pointer = *receiver;
-    value = CALL_GENERATED_CODE(entry, entry_address, function,
-                                receiver_pointer, argc, args);
-  }
-
-#ifdef DEBUG
-  value->Verify();
-#endif
-
-  // Update the pending exception flag and return the value.
-  *has_pending_exception = value->IsException();
-  ASSERT(*has_pending_exception == Top::has_pending_exception());
-  if (*has_pending_exception) {
-    Top::ReportPendingMessages();
-    if (Top::pending_exception() == Failure::OutOfMemoryException()) {
-      if (!HandleScopeImplementer::instance()->ignore_out_of_memory()) {
-        V8::FatalProcessOutOfMemory("JS", true);
-      }
-    }
-    return Handle<Object>();
-  } else {
-    Top::clear_pending_message();
-  }
-
-  return Handle<Object>(value->ToObjectUnchecked());
-}
-
-
-Handle<Object> Execution::Call(Handle<JSFunction> func,
-                               Handle<Object> receiver,
-                               int argc,
-                               Object*** args,
-                               bool* pending_exception) {
-  return Invoke(false, func, receiver, argc, args, pending_exception);
-}
-
-
-Handle<Object> Execution::New(Handle<JSFunction> func, int argc,
-                              Object*** args, bool* pending_exception) {
-  return Invoke(true, func, Top::global(), argc, args, pending_exception);
-}
-
-
-Handle<Object> Execution::TryCall(Handle<JSFunction> func,
-                                  Handle<Object> receiver,
-                                  int argc,
-                                  Object*** args,
-                                  bool* caught_exception) {
-  // Enter a try-block while executing the JavaScript code. To avoid
-  // duplicate error printing it must be non-verbose.  Also, to avoid
-  // creating message objects during stack overflow we shouldn't
-  // capture messages.
-  v8::TryCatch catcher;
-  catcher.SetVerbose(false);
-  catcher.SetCaptureMessage(false);
-
-  Handle<Object> result = Invoke(false, func, receiver, argc, args,
-                                 caught_exception);
-
-  if (*caught_exception) {
-    ASSERT(catcher.HasCaught());
-    ASSERT(Top::has_pending_exception());
-    ASSERT(Top::external_caught_exception());
-    if (Top::pending_exception() == Heap::termination_exception()) {
-      result = Factory::termination_exception();
-    } else {
-      result = v8::Utils::OpenHandle(*catcher.Exception());
-    }
-    Top::OptionalRescheduleException(true);
-  }
-
-  ASSERT(!Top::has_pending_exception());
-  ASSERT(!Top::external_caught_exception());
-  return result;
-}
-
-
-Handle<Object> Execution::GetFunctionDelegate(Handle<Object> object) {
-  ASSERT(!object->IsJSFunction());
-
-  // If you return a function from here, it will be called when an
-  // attempt is made to call the given object as a function.
-
-  // Regular expressions can be called as functions in both Firefox
-  // and Safari so we allow it too.
-  if (object->IsJSRegExp()) {
-    Handle<String> exec = Factory::exec_symbol();
-    // TODO(lrn): Bug 617.  We should use the default function here, not the
-    // one on the RegExp object.
-    Object* exec_function;
-    { MaybeObject* maybe_exec_function = object->GetProperty(*exec);
-      // This can lose an exception, but the alternative is to put a failure
-      // object in a handle, which is not GC safe.
-      if (!maybe_exec_function->ToObject(&exec_function)) {
-        return Factory::undefined_value();
-      }
-    }
-    return Handle<Object>(exec_function);
-  }
-
-  // Objects created through the API can have an instance-call handler
-  // that should be used when calling the object as a function.
-  if (object->IsHeapObject() &&
-      HeapObject::cast(*object)->map()->has_instance_call_handler()) {
-    return Handle<JSFunction>(
-        Top::global_context()->call_as_function_delegate());
-  }
-
-  return Factory::undefined_value();
-}
-
-
-Handle<Object> Execution::GetConstructorDelegate(Handle<Object> object) {
-  ASSERT(!object->IsJSFunction());
-
-  // If you return a function from here, it will be called when an
-  // attempt is made to call the given object as a constructor.
-
-  // Objects created through the API can have an instance-call handler
-  // that should be used when calling the object as a function.
-  if (object->IsHeapObject() &&
-      HeapObject::cast(*object)->map()->has_instance_call_handler()) {
-    return Handle<JSFunction>(
-        Top::global_context()->call_as_constructor_delegate());
-  }
-
-  return Factory::undefined_value();
-}
-
-
-// Static state for stack guards.
-StackGuard::ThreadLocal StackGuard::thread_local_;
-
-
-bool StackGuard::IsStackOverflow() {
-  ExecutionAccess access;
-  return (thread_local_.jslimit_ != kInterruptLimit &&
-          thread_local_.climit_ != kInterruptLimit);
-}
-
-
-void StackGuard::EnableInterrupts() {
-  ExecutionAccess access;
-  if (has_pending_interrupts(access)) {
-    set_interrupt_limits(access);
-  }
-}
-
-
-void StackGuard::SetStackLimit(uintptr_t limit) {
-  ExecutionAccess access;
-  // If the current limits are special (eg due to a pending interrupt) then
-  // leave them alone.
-  uintptr_t jslimit = SimulatorStack::JsLimitFromCLimit(limit);
-  if (thread_local_.jslimit_ == thread_local_.real_jslimit_) {
-    thread_local_.jslimit_ = jslimit;
-  }
-  if (thread_local_.climit_ == thread_local_.real_climit_) {
-    thread_local_.climit_ = limit;
-  }
-  thread_local_.real_climit_ = limit;
-  thread_local_.real_jslimit_ = jslimit;
-}
-
-
-void StackGuard::DisableInterrupts() {
-  ExecutionAccess access;
-  reset_limits(access);
-}
-
-
-bool StackGuard::IsInterrupted() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & INTERRUPT;
-}
-
-
-void StackGuard::Interrupt() {
-  ExecutionAccess access;
-  thread_local_.interrupt_flags_ |= INTERRUPT;
-  set_interrupt_limits(access);
-}
-
-
-bool StackGuard::IsPreempted() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & PREEMPT;
-}
-
-
-void StackGuard::Preempt() {
-  ExecutionAccess access;
-  thread_local_.interrupt_flags_ |= PREEMPT;
-  set_interrupt_limits(access);
-}
-
-
-bool StackGuard::IsTerminateExecution() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & TERMINATE;
-}
-
-
-void StackGuard::TerminateExecution() {
-  ExecutionAccess access;
-  thread_local_.interrupt_flags_ |= TERMINATE;
-  set_interrupt_limits(access);
-}
-
-
-bool StackGuard::IsRuntimeProfilerTick() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & RUNTIME_PROFILER_TICK;
-}
-
-
-void StackGuard::RequestRuntimeProfilerTick() {
-  // Ignore calls if we're not optimizing or if we can't get the lock.
-  if (FLAG_opt && ExecutionAccess::TryLock()) {
-    thread_local_.interrupt_flags_ |= RUNTIME_PROFILER_TICK;
-    if (thread_local_.postpone_interrupts_nesting_ == 0) {
-      thread_local_.jslimit_ = thread_local_.climit_ = kInterruptLimit;
-      Heap::SetStackLimits();
-    }
-    ExecutionAccess::Unlock();
-  }
-}
-
-
-#ifdef ENABLE_DEBUGGER_SUPPORT
-bool StackGuard::IsDebugBreak() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & DEBUGBREAK;
-}
-
-
-void StackGuard::DebugBreak() {
-  ExecutionAccess access;
-  thread_local_.interrupt_flags_ |= DEBUGBREAK;
-  set_interrupt_limits(access);
-}
-
-
-bool StackGuard::IsDebugCommand() {
-  ExecutionAccess access;
-  return thread_local_.interrupt_flags_ & DEBUGCOMMAND;
-}
-
-
-void StackGuard::DebugCommand() {
-  if (FLAG_debugger_auto_break) {
-    ExecutionAccess access;
-    thread_local_.interrupt_flags_ |= DEBUGCOMMAND;
-    set_interrupt_limits(access);
-  }
-}
-#endif
-
-void StackGuard::Continue(InterruptFlag after_what) {
-  ExecutionAccess access;
-  thread_local_.interrupt_flags_ &= ~static_cast<int>(after_what);
-  if (!should_postpone_interrupts(access) && !has_pending_interrupts(access)) {
-    reset_limits(access);
-  }
-}
-
-
-int StackGuard::ArchiveSpacePerThread() {
-  return sizeof(ThreadLocal);
-}
-
-
-char* StackGuard::ArchiveStackGuard(char* to) {
-  ExecutionAccess access;
-  memcpy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));
-  ThreadLocal blank;
-  thread_local_ = blank;
-  return to + sizeof(ThreadLocal);
-}
-
-
-char* StackGuard::RestoreStackGuard(char* from) {
-  ExecutionAccess access;
-  memcpy(reinterpret_cast<char*>(&thread_local_), from, sizeof(ThreadLocal));
-  Heap::SetStackLimits();
-  return from + sizeof(ThreadLocal);
-}
-
-
-static internal::Thread::LocalStorageKey stack_limit_key =
-    internal::Thread::CreateThreadLocalKey();
-
-
-void StackGuard::FreeThreadResources() {
-  Thread::SetThreadLocal(
-      stack_limit_key,
-      reinterpret_cast<void*>(thread_local_.real_climit_));
-}
-
-
-void StackGuard::ThreadLocal::Clear() {
-  real_jslimit_ = kIllegalLimit;
-  jslimit_ = kIllegalLimit;
-  real_climit_ = kIllegalLimit;
-  climit_ = kIllegalLimit;
-  nesting_ = 0;
-  postpone_interrupts_nesting_ = 0;
-  interrupt_flags_ = 0;
-  Heap::SetStackLimits();
-}
-
-
-void StackGuard::ThreadLocal::Initialize() {
-  if (real_climit_ == kIllegalLimit) {
-    // Takes the address of the limit variable in order to find out where
-    // the top of stack is right now.
-    const uintptr_t kLimitSize = FLAG_stack_size * KB;
-    uintptr_t limit = reinterpret_cast<uintptr_t>(&limit) - kLimitSize;
-    ASSERT(reinterpret_cast<uintptr_t>(&limit) > kLimitSize);
-    real_jslimit_ = SimulatorStack::JsLimitFromCLimit(limit);
-    jslimit_ = SimulatorStack::JsLimitFromCLimit(limit);
-    real_climit_ = limit;
-    climit_ = limit;
-    Heap::SetStackLimits();
-  }
-  nesting_ = 0;
-  postpone_interrupts_nesting_ = 0;
-  interrupt_flags_ = 0;
-}
-
-
-void StackGuard::ClearThread(const ExecutionAccess& lock) {
-  thread_local_.Clear();
-}
-
-
-void StackGuard::InitThread(const ExecutionAccess& lock) {
-  thread_local_.Initialize();
-  void* stored_limit = Thread::GetThreadLocal(stack_limit_key);
-  // You should hold the ExecutionAccess lock when you call this.
-  if (stored_limit != NULL) {
-    StackGuard::SetStackLimit(reinterpret_cast<intptr_t>(stored_limit));
-  }
-}
-
-
-// --- C a l l s   t o   n a t i v e s ---
-
-#define RETURN_NATIVE_CALL(name, argc, argv, has_pending_exception) \
-  do {                                                              \
-    Object** args[argc] = argv;                                     \
-    ASSERT(has_pending_exception != NULL);                          \
-    return Call(Top::name##_fun(), Top::builtins(), argc, args,     \
-                has_pending_exception);                             \
-  } while (false)
-
-
-Handle<Object> Execution::ToBoolean(Handle<Object> obj) {
-  // See the similar code in runtime.js:ToBoolean.
-  if (obj->IsBoolean()) return obj;
-  bool result = true;
-  if (obj->IsString()) {
-    result = Handle<String>::cast(obj)->length() != 0;
-  } else if (obj->IsNull() || obj->IsUndefined()) {
-    result = false;
-  } else if (obj->IsNumber()) {
-    double value = obj->Number();
-    result = !((value == 0) || isnan(value));
-  }
-  return Handle<Object>(Heap::ToBoolean(result));
-}
-
-
-Handle<Object> Execution::ToNumber(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_number, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToString(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_string, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToDetailString(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_detail_string, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToObject(Handle<Object> obj, bool* exc) {
-  if (obj->IsJSObject()) return obj;
-  RETURN_NATIVE_CALL(to_object, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToInteger(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_integer, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToUint32(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_uint32, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::ToInt32(Handle<Object> obj, bool* exc) {
-  RETURN_NATIVE_CALL(to_int32, 1, { obj.location() }, exc);
-}
-
-
-Handle<Object> Execution::NewDate(double time, bool* exc) {
-  Handle<Object> time_obj = Factory::NewNumber(time);
-  RETURN_NATIVE_CALL(create_date, 1, { time_obj.location() }, exc);
-}
-
-
-#undef RETURN_NATIVE_CALL
-
-
-Handle<JSRegExp> Execution::NewJSRegExp(Handle<String> pattern,
-                                        Handle<String> flags,
-                                        bool* exc) {
-  Handle<Object> re_obj = RegExpImpl::CreateRegExpLiteral(
-      Handle<JSFunction>(Top::global_context()->regexp_function()),
-      pattern,
-      flags,
-      exc);
-  if (*exc) return Handle<JSRegExp>();
-  return Handle<JSRegExp>::cast(re_obj);
-}
-
-
-Handle<Object> Execution::CharAt(Handle<String> string, uint32_t index) {
-  int int_index = static_cast<int>(index);
-  if (int_index < 0 || int_index >= string->length()) {
-    return Factory::undefined_value();
-  }
-
-  Handle<Object> char_at =
-      GetProperty(Top::builtins(), Factory::char_at_symbol());
-  if (!char_at->IsJSFunction()) {
-    return Factory::undefined_value();
-  }
-
-  bool caught_exception;
-  Handle<Object> index_object = Factory::NewNumberFromInt(int_index);
-  Object** index_arg[] = { index_object.location() };
-  Handle<Object> result = TryCall(Handle<JSFunction>::cast(char_at),
-                                  string,
-                                  ARRAY_SIZE(index_arg),
-                                  index_arg,
-                                  &caught_exception);
-  if (caught_exception) {
-    return Factory::undefined_value();
-  }
-  return result;
-}
-
-
-Handle<JSFunction> Execution::InstantiateFunction(
-    Handle<FunctionTemplateInfo> data, bool* exc) {
-  // Fast case: see if the function has already been instantiated
-  int serial_number = Smi::cast(data->serial_number())->value();
-  Object* elm = Top::global_context()->function_cache()->
-      GetElementNoExceptionThrown(serial_number);
-  if (elm->IsJSFunction()) return Handle<JSFunction>(JSFunction::cast(elm));
-  // The function has not yet been instantiated in this context; do it.
-  Object** args[1] = { Handle<Object>::cast(data).location() };
-  Handle<Object> result =
-      Call(Top::instantiate_fun(), Top::builtins(), 1, args, exc);
-  if (*exc) return Handle<JSFunction>::null();
-  return Handle<JSFunction>::cast(result);
-}
-
-
-Handle<JSObject> Execution::InstantiateObject(Handle<ObjectTemplateInfo> data,
-                                              bool* exc) {
-  if (data->property_list()->IsUndefined() &&
-      !data->constructor()->IsUndefined()) {
-    // Initialization to make gcc happy.
-    Object* result = NULL;
-    {
-      HandleScope scope;
-      Handle<FunctionTemplateInfo> cons_template =
-          Handle<FunctionTemplateInfo>(
-              FunctionTemplateInfo::cast(data->constructor()));
-      Handle<JSFunction> cons = InstantiateFunction(cons_template, exc);
-      if (*exc) return Handle<JSObject>::null();
-      Handle<Object> value = New(cons, 0, NULL, exc);
-      if (*exc) return Handle<JSObject>::null();
-      result = *value;
-    }
-    ASSERT(!*exc);
-    return Handle<JSObject>(JSObject::cast(result));
-  } else {
-    Object** args[1] = { Handle<Object>::cast(data).location() };
-    Handle<Object> result =
-        Call(Top::instantiate_fun(), Top::builtins(), 1, args, exc);
-    if (*exc) return Handle<JSObject>::null();
-    return Handle<JSObject>::cast(result);
-  }
-}
-
-
-void Execution::ConfigureInstance(Handle<Object> instance,
-                                  Handle<Object> instance_template,
-                                  bool* exc) {
-  Object** args[2] = { instance.location(), instance_template.location() };
-  Execution::Call(Top::configure_instance_fun(), Top::builtins(), 2, args, exc);
-}
-
-
-Handle<String> Execution::GetStackTraceLine(Handle<Object> recv,
-                                            Handle<JSFunction> fun,
-                                            Handle<Object> pos,
-                                            Handle<Object> is_global) {
-  const int argc = 4;
-  Object** args[argc] = { recv.location(),
-                          Handle<Object>::cast(fun).location(),
-                          pos.location(),
-                          is_global.location() };
-  bool caught_exception = false;
-  Handle<Object> result = TryCall(Top::get_stack_trace_line_fun(),
-                                  Top::builtins(), argc, args,
-                                  &caught_exception);
-  if (caught_exception || !result->IsString()) return Factory::empty_symbol();
-  return Handle<String>::cast(result);
-}
-
-
-static Object* RuntimePreempt() {
-  // Clear the preempt request flag.
-  StackGuard::Continue(PREEMPT);
-
-  ContextSwitcher::PreemptionReceived();
-
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  if (Debug::InDebugger()) {
-    // If currently in the debugger don't do any actual preemption but record
-    // that preemption occoured while in the debugger.
-    Debug::PreemptionWhileInDebugger();
-  } else {
-    // Perform preemption.
-    v8::Unlocker unlocker;
-    Thread::YieldCPU();
-  }
-#else
-  // Perform preemption.
-  v8::Unlocker unlocker;
-  Thread::YieldCPU();
-#endif
-
-  return Heap::undefined_value();
-}
-
-
-#ifdef ENABLE_DEBUGGER_SUPPORT
-Object* Execution::DebugBreakHelper() {
-  // Just continue if breaks are disabled.
-  if (Debug::disable_break()) {
-    return Heap::undefined_value();
-  }
-
-  // Ignore debug break during bootstrapping.
-  if (Bootstrapper::IsActive()) {
-    return Heap::undefined_value();
-  }
-
-  {
-    JavaScriptFrameIterator it;
-    ASSERT(!it.done());
-    Object* fun = it.frame()->function();
-    if (fun && fun->IsJSFunction()) {
-      // Don't stop in builtin functions.
-      if (JSFunction::cast(fun)->IsBuiltin()) {
-        return Heap::undefined_value();
-      }
-      GlobalObject* global = JSFunction::cast(fun)->context()->global();
-      // Don't stop in debugger functions.
-      if (Debug::IsDebugGlobal(global)) {
-        return Heap::undefined_value();
-      }
-    }
-  }
-
-  // Collect the break state before clearing the flags.
-  bool debug_command_only =
-      StackGuard::IsDebugCommand() && !StackGuard::IsDebugBreak();
-
-  // Clear the debug break request flag.
-  StackGuard::Continue(DEBUGBREAK);
-
-  ProcessDebugMesssages(debug_command_only);
-
-  // Return to continue execution.
-  return Heap::undefined_value();
-}
-
-void Execution::ProcessDebugMesssages(bool debug_command_only) {
-  // Clear the debug command request flag.
-  StackGuard::Continue(DEBUGCOMMAND);
-
-  HandleScope scope;
-  // Enter the debugger. Just continue if we fail to enter the debugger.
-  EnterDebugger debugger;
-  if (debugger.FailedToEnter()) {
-    return;
-  }
-
-  // Notify the debug event listeners. Indicate auto continue if the break was
-  // a debug command break.
-  Debugger::OnDebugBreak(Factory::undefined_value(), debug_command_only);
-}
-
-
-#endif
-
-MaybeObject* Execution::HandleStackGuardInterrupt() {
-  Counters::stack_interrupts.Increment();
-  if (StackGuard::IsRuntimeProfilerTick()) {
-    Counters::runtime_profiler_ticks.Increment();
-    StackGuard::Continue(RUNTIME_PROFILER_TICK);
-    RuntimeProfiler::OptimizeNow();
-  }
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  if (StackGuard::IsDebugBreak() || StackGuard::IsDebugCommand()) {
-    DebugBreakHelper();
-  }
-#endif
-  if (StackGuard::IsPreempted()) RuntimePreempt();
-  if (StackGuard::IsTerminateExecution()) {
-    StackGuard::Continue(TERMINATE);
-    return Top::TerminateExecution();
-  }
-  if (StackGuard::IsInterrupted()) {
-    StackGuard::Continue(INTERRUPT);
-    return Top::StackOverflow();
-  }
-  return Heap::undefined_value();
-}
-
-} }  // namespace v8::internal