2012-02-08 09:55:25 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2008-07-03 15:10:15 +00:00
|
|
|
// 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"
|
|
|
|
|
2012-04-05 14:10:39 +00:00
|
|
|
#include "assembler.h"
|
2011-03-18 20:35:07 +00:00
|
|
|
#include "isolate.h"
|
2011-08-03 11:12:46 +00:00
|
|
|
#include "elements.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
#include "bootstrapper.h"
|
|
|
|
#include "debug.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
#include "deoptimizer.h"
|
2012-04-05 14:10:39 +00:00
|
|
|
#include "frames.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
#include "heap-profiler.h"
|
|
|
|
#include "hydrogen.h"
|
|
|
|
#include "lithium-allocator.h"
|
2012-11-08 13:44:59 +00:00
|
|
|
#include "objects.h"
|
2012-03-12 13:56:56 +00:00
|
|
|
#include "once.h"
|
|
|
|
#include "platform.h"
|
2013-04-15 13:57:41 +00:00
|
|
|
#include "sampler.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
#include "runtime-profiler.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
#include "serialize.h"
|
2011-09-19 18:36:47 +00:00
|
|
|
#include "store-buffer.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2012-03-12 13:56:56 +00:00
|
|
|
V8_DECLARE_ONCE(init_once);
|
2011-03-31 16:17:37 +00:00
|
|
|
|
2012-01-04 08:48:35 +00:00
|
|
|
List<CallCompletedCallback>* V8::call_completed_callbacks_ = NULL;
|
2013-06-11 10:41:14 +00:00
|
|
|
v8::ArrayBuffer::Allocator* V8::array_buffer_allocator_ = NULL;
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2010-11-16 08:01:45 +00:00
|
|
|
|
2010-03-17 14:53:16 +00:00
|
|
|
bool V8::Initialize(Deserializer* des) {
|
2011-03-31 16:17:37 +00:00
|
|
|
InitializeOncePerProcess();
|
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
// The current thread may not yet had entered an isolate to run.
|
|
|
|
// Note the Isolate::Current() may be non-null because for various
|
2013-09-06 11:24:26 +00:00
|
|
|
// initialization purposes an initializing thread may be assigned an isolate
|
|
|
|
// but not actually enter it.
|
2011-03-18 20:35:07 +00:00
|
|
|
if (i::Isolate::CurrentPerIsolateThreadData() == NULL) {
|
|
|
|
i::Isolate::EnterDefaultIsolate();
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(i::Isolate::CurrentPerIsolateThreadData() != NULL);
|
2011-04-11 23:46:22 +00:00
|
|
|
ASSERT(i::Isolate::CurrentPerIsolateThreadData()->thread_id().Equals(
|
|
|
|
i::ThreadId::Current()));
|
2011-03-18 20:35:07 +00:00
|
|
|
ASSERT(i::Isolate::CurrentPerIsolateThreadData()->isolate() ==
|
|
|
|
i::Isolate::Current());
|
|
|
|
|
|
|
|
Isolate* isolate = Isolate::Current();
|
2013-09-03 09:35:26 +00:00
|
|
|
if (isolate->IsDead()) return false;
|
2011-03-18 20:35:07 +00:00
|
|
|
if (isolate->IsInitialized()) return true;
|
2009-05-25 19:39:52 +00:00
|
|
|
|
2011-03-18 20:35:07 +00:00
|
|
|
return isolate->Init(des);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-01 14:26:53 +00:00
|
|
|
bool V8::TearDown() {
|
|
|
|
Isolate* isolate = Isolate::UncheckedCurrent();
|
|
|
|
if (isolate != NULL) {
|
|
|
|
ASSERT(isolate->IsDefaultIsolate());
|
|
|
|
if (isolate->IsInitialized()) isolate->TearDown();
|
|
|
|
delete isolate;
|
|
|
|
}
|
|
|
|
|
|
|
|
// V8 was never initialized, nothing to do.
|
|
|
|
if (Acquire_Load(&init_once) == ONCE_STATE_UNINITIALIZED) return true;
|
|
|
|
|
|
|
|
// TODO(dcarney): Everything below this should be in some sort of mutex...
|
|
|
|
Atomic32 living_isolates = Isolate::GetLivingIsolates();
|
2012-03-27 07:37:06 +00:00
|
|
|
|
2013-10-01 14:26:53 +00:00
|
|
|
// All isolates have to be torn down before clearing the LOperand
|
2012-07-19 18:58:23 +00:00
|
|
|
// caches so that the optimizing compiler thread (if running)
|
|
|
|
// doesn't see an inconsistent view of the lithium instructions.
|
2013-10-01 14:26:53 +00:00
|
|
|
if (living_isolates != 0) return false;
|
2012-07-19 18:58:23 +00:00
|
|
|
|
2012-03-27 10:51:13 +00:00
|
|
|
ElementsAccessor::TearDown();
|
2012-03-28 13:12:00 +00:00
|
|
|
LOperand::TearDownCaches();
|
2012-11-26 13:12:35 +00:00
|
|
|
ExternalReference::TearDownMathExpData();
|
2012-03-29 09:45:46 +00:00
|
|
|
RegisteredExtension::UnregisterAll();
|
2013-02-12 11:57:51 +00:00
|
|
|
Isolate::GlobalTearDown();
|
2012-03-27 10:51:13 +00:00
|
|
|
|
2012-01-04 08:48:35 +00:00
|
|
|
delete call_completed_callbacks_;
|
|
|
|
call_completed_callbacks_ = NULL;
|
2012-04-13 14:08:31 +00:00
|
|
|
|
2013-04-15 13:57:41 +00:00
|
|
|
Sampler::TearDown();
|
2013-10-01 14:26:53 +00:00
|
|
|
return true;
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
2009-05-25 19:39:52 +00:00
|
|
|
|
2012-02-27 15:15:53 +00:00
|
|
|
void V8::SetReturnAddressLocationResolver(
|
|
|
|
ReturnAddressLocationResolver resolver) {
|
|
|
|
StackFrame::SetReturnAddressLocationResolver(resolver);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-18 08:23:49 +00:00
|
|
|
// Used by JavaScript APIs
|
2011-10-24 12:12:21 +00:00
|
|
|
uint32_t V8::Random(Context* context) {
|
2012-08-17 09:03:08 +00:00
|
|
|
ASSERT(context->IsNativeContext());
|
2011-10-24 12:12:21 +00:00
|
|
|
ByteArray* seed = context->random_seed();
|
2013-09-10 11:13:55 +00:00
|
|
|
uint32_t* state = reinterpret_cast<uint32_t*>(seed->GetDataStartAddress());
|
|
|
|
|
|
|
|
// When we get here, the RNG must have been initialized,
|
|
|
|
// see the Genesis constructor in file bootstrapper.cc.
|
|
|
|
ASSERT_NE(0, state[0]);
|
|
|
|
ASSERT_NE(0, state[1]);
|
2010-11-18 08:23:49 +00:00
|
|
|
|
2013-09-10 11:13:55 +00:00
|
|
|
// Mix the bits. Never replaces state[i] with 0 if it is nonzero.
|
|
|
|
state[0] = 18273 * (state[0] & 0xFFFF) + (state[0] >> 16);
|
|
|
|
state[1] = 36969 * (state[1] & 0xFFFF) + (state[1] >> 16);
|
2010-11-18 08:23:49 +00:00
|
|
|
|
2013-09-10 11:13:55 +00:00
|
|
|
return (state[0] << 14) + (state[1] & 0x3FFFF);
|
2009-06-15 08:04:47 +00:00
|
|
|
}
|
|
|
|
|
2009-08-20 08:12:30 +00:00
|
|
|
|
2012-01-04 08:48:35 +00:00
|
|
|
void V8::AddCallCompletedCallback(CallCompletedCallback callback) {
|
|
|
|
if (call_completed_callbacks_ == NULL) { // Lazy init.
|
|
|
|
call_completed_callbacks_ = new List<CallCompletedCallback>();
|
|
|
|
}
|
|
|
|
for (int i = 0; i < call_completed_callbacks_->length(); i++) {
|
|
|
|
if (callback == call_completed_callbacks_->at(i)) return;
|
|
|
|
}
|
|
|
|
call_completed_callbacks_->Add(callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void V8::RemoveCallCompletedCallback(CallCompletedCallback callback) {
|
|
|
|
if (call_completed_callbacks_ == NULL) return;
|
|
|
|
for (int i = 0; i < call_completed_callbacks_->length(); i++) {
|
|
|
|
if (callback == call_completed_callbacks_->at(i)) {
|
|
|
|
call_completed_callbacks_->Remove(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void V8::FireCallCompletedCallback(Isolate* isolate) {
|
2012-11-08 13:44:59 +00:00
|
|
|
bool has_call_completed_callbacks = call_completed_callbacks_ != NULL;
|
|
|
|
bool observer_delivery_pending =
|
|
|
|
FLAG_harmony_observation && isolate->observer_delivery_pending();
|
|
|
|
if (!has_call_completed_callbacks && !observer_delivery_pending) return;
|
2012-01-04 08:48:35 +00:00
|
|
|
HandleScopeImplementer* handle_scope_implementer =
|
|
|
|
isolate->handle_scope_implementer();
|
|
|
|
if (!handle_scope_implementer->CallDepthIsZero()) return;
|
|
|
|
// Fire callbacks. Increase call depth to prevent recursive callbacks.
|
|
|
|
handle_scope_implementer->IncrementCallDepth();
|
2012-11-08 13:44:59 +00:00
|
|
|
if (observer_delivery_pending) {
|
|
|
|
JSObject::DeliverChangeRecords(isolate);
|
|
|
|
}
|
|
|
|
if (has_call_completed_callbacks) {
|
|
|
|
for (int i = 0; i < call_completed_callbacks_->length(); i++) {
|
|
|
|
call_completed_callbacks_->at(i)();
|
|
|
|
}
|
2012-01-04 08:48:35 +00:00
|
|
|
}
|
|
|
|
handle_scope_implementer->DecrementCallDepth();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-07 08:18:51 +00:00
|
|
|
// Use a union type to avoid type-aliasing optimizations in GCC.
|
|
|
|
typedef union {
|
|
|
|
double double_value;
|
|
|
|
uint64_t uint64_t_value;
|
|
|
|
} double_int_union;
|
|
|
|
|
|
|
|
|
2011-10-24 12:12:21 +00:00
|
|
|
Object* V8::FillHeapNumberWithRandom(Object* heap_number,
|
|
|
|
Context* context) {
|
2012-03-09 09:51:34 +00:00
|
|
|
double_int_union r;
|
2011-10-24 12:12:21 +00:00
|
|
|
uint64_t random_bits = Random(context);
|
2010-04-12 10:07:50 +00:00
|
|
|
// Convert 32 random bits to 0.(32 random bits) in a double
|
|
|
|
// by computing:
|
|
|
|
// ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
|
2012-03-09 09:51:34 +00:00
|
|
|
static const double binary_million = 1048576.0;
|
|
|
|
r.double_value = binary_million;
|
|
|
|
r.uint64_t_value |= random_bits;
|
|
|
|
r.double_value -= binary_million;
|
2010-04-07 08:18:51 +00:00
|
|
|
|
2012-03-09 09:51:34 +00:00
|
|
|
HeapNumber::cast(heap_number)->set_value(r.double_value);
|
2010-04-07 08:18:51 +00:00
|
|
|
return heap_number;
|
2009-06-15 08:04:47 +00:00
|
|
|
}
|
|
|
|
|
2013-07-05 09:52:11 +00:00
|
|
|
|
2012-03-12 13:56:56 +00:00
|
|
|
void V8::InitializeOncePerProcessImpl() {
|
2013-01-21 12:04:40 +00:00
|
|
|
FlagList::EnforceFlagImplications();
|
2011-10-11 15:52:15 +00:00
|
|
|
if (FLAG_stress_compaction) {
|
|
|
|
FLAG_force_marking_deque_overflows = true;
|
|
|
|
FLAG_gc_global = true;
|
|
|
|
FLAG_max_new_space_size = (1 << (kPageSizeBits - 10)) * 2;
|
|
|
|
}
|
2013-08-05 09:02:47 +00:00
|
|
|
|
2013-08-22 16:14:37 +00:00
|
|
|
if (FLAG_concurrent_recompilation &&
|
2013-08-05 09:28:22 +00:00
|
|
|
(FLAG_trace_hydrogen || FLAG_trace_hydrogen_stubs)) {
|
2013-08-22 16:14:37 +00:00
|
|
|
FLAG_concurrent_recompilation = false;
|
|
|
|
PrintF("Concurrent recompilation has been disabled for tracing.\n");
|
2013-08-05 09:02:47 +00:00
|
|
|
}
|
2013-06-19 08:57:26 +00:00
|
|
|
|
|
|
|
if (FLAG_sweeper_threads <= 0) {
|
|
|
|
if (FLAG_concurrent_sweeping) {
|
|
|
|
FLAG_sweeper_threads = SystemThreadManager::
|
|
|
|
NumberOfParallelSystemThreads(
|
|
|
|
SystemThreadManager::CONCURRENT_SWEEPING);
|
|
|
|
} else if (FLAG_parallel_sweeping) {
|
|
|
|
FLAG_sweeper_threads = SystemThreadManager::
|
|
|
|
NumberOfParallelSystemThreads(
|
|
|
|
SystemThreadManager::PARALLEL_SWEEPING);
|
|
|
|
}
|
|
|
|
if (FLAG_sweeper_threads == 0) {
|
|
|
|
FLAG_concurrent_sweeping = false;
|
|
|
|
FLAG_parallel_sweeping = false;
|
|
|
|
}
|
|
|
|
} else if (!FLAG_concurrent_sweeping && !FLAG_parallel_sweeping) {
|
|
|
|
FLAG_sweeper_threads = 0;
|
|
|
|
}
|
|
|
|
|
2013-08-22 16:14:37 +00:00
|
|
|
if (FLAG_concurrent_recompilation &&
|
2013-06-19 08:57:26 +00:00
|
|
|
SystemThreadManager::NumberOfParallelSystemThreads(
|
|
|
|
SystemThreadManager::PARALLEL_RECOMPILATION) == 0) {
|
2013-08-22 16:14:37 +00:00
|
|
|
FLAG_concurrent_recompilation = false;
|
2013-06-19 08:57:26 +00:00
|
|
|
}
|
|
|
|
|
2013-04-15 13:57:41 +00:00
|
|
|
Sampler::SetUp();
|
2013-01-21 12:04:40 +00:00
|
|
|
CPU::SetUp();
|
|
|
|
OS::PostSetUp();
|
|
|
|
ElementsAccessor::InitializeOncePerProcess();
|
2012-03-12 13:56:56 +00:00
|
|
|
LOperand::SetUpCaches();
|
2012-04-05 14:10:39 +00:00
|
|
|
SetUpJSCallerSavedCodeData();
|
|
|
|
ExternalReference::SetUp();
|
2013-05-21 12:03:49 +00:00
|
|
|
Bootstrapper::InitializeOncePerProcess();
|
2012-03-12 13:56:56 +00:00
|
|
|
}
|
|
|
|
|
2013-07-05 09:52:11 +00:00
|
|
|
|
2012-03-12 13:56:56 +00:00
|
|
|
void V8::InitializeOncePerProcess() {
|
|
|
|
CallOnce(&init_once, &InitializeOncePerProcessImpl);
|
2011-03-31 16:17:37 +00:00
|
|
|
}
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
} } // namespace v8::internal
|