From 48c16454b18bbd9702fcab5265e5302efbd8d6d4 Mon Sep 17 00:00:00 2001 From: "mstarzinger@chromium.org" Date: Mon, 24 Jun 2013 11:10:40 +0000 Subject: [PATCH] Revert "Remove IsInitialized checks from inlined API functions." This reverts r15277 due to failures in layout tests. Apparently Blink still initializes the Isolate by calling v8::Null() as the first API function on some paths. TBR=svenpanne@chromium.org TEST=webkit:crypto/worker-random-values-concurrent.html Review URL: https://codereview.chromium.org/17577008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@15281 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- include/v8.h | 22 ++++++++++---------- src/api.cc | 10 --------- src/isolate.cc | 2 ++ test/cctest/test-api.cc | 45 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 58 insertions(+), 21 deletions(-) diff --git a/include/v8.h b/include/v8.h index 2d21355d60..628c5d1af1 100644 --- a/include/v8.h +++ b/include/v8.h @@ -5301,6 +5301,7 @@ class Internals { static const int kExternalTwoByteRepresentationTag = 0x02; static const int kExternalAsciiRepresentationTag = 0x06; + static const int kIsolateStateOffset = 0; static const int kIsolateEmbedderDataOffset = 1 * kApiPointerSize; static const int kIsolateRootsOffset = 3 * kApiPointerSize; static const int kUndefinedValueRootIndex = 5; @@ -5325,12 +5326,6 @@ class Internals { static const int kUndefinedOddballKind = 5; static const int kNullOddballKind = 3; -#ifdef V8_ENABLE_CHECKS - static void CheckInitialized(v8::Isolate* isolate); -#else - static void CheckInitialized(v8::Isolate* isolate) { } -#endif - V8_INLINE(static bool HasHeapObjectTag(internal::Object* value)) { return ((reinterpret_cast(value) & kHeapObjectTagMask) == kHeapObjectTag); @@ -5364,6 +5359,11 @@ class Internals { return representation == kExternalTwoByteRepresentationTag; } + V8_INLINE(static bool IsInitialized(v8::Isolate* isolate)) { + uint8_t* addr = reinterpret_cast(isolate) + kIsolateStateOffset; + return *reinterpret_cast(addr) == 1; + } + V8_INLINE(static uint8_t GetNodeFlag(internal::Object** obj, int shift)) { uint8_t* addr = reinterpret_cast(obj) + kNodeFlagsOffset; return *addr & (1 << shift); @@ -5939,7 +5939,7 @@ String* String::Cast(v8::Value* value) { Local String::Empty(Isolate* isolate) { typedef internal::Object* S; typedef internal::Internals I; - I::CheckInitialized(isolate); + if (!I::IsInitialized(isolate)) return Empty(); S* slot = I::GetRoot(isolate, I::kEmptyStringRootIndex); return Local(reinterpret_cast(slot)); } @@ -6292,7 +6292,7 @@ ReturnValue PropertyCallbackInfo::GetReturnValue() const { Handle Undefined(Isolate* isolate) { typedef internal::Object* S; typedef internal::Internals I; - I::CheckInitialized(isolate); + if (!I::IsInitialized(isolate)) return Undefined(); S* slot = I::GetRoot(isolate, I::kUndefinedValueRootIndex); return Handle(reinterpret_cast(slot)); } @@ -6301,7 +6301,7 @@ Handle Undefined(Isolate* isolate) { Handle Null(Isolate* isolate) { typedef internal::Object* S; typedef internal::Internals I; - I::CheckInitialized(isolate); + if (!I::IsInitialized(isolate)) return Null(); S* slot = I::GetRoot(isolate, I::kNullValueRootIndex); return Handle(reinterpret_cast(slot)); } @@ -6310,7 +6310,7 @@ Handle Null(Isolate* isolate) { Handle True(Isolate* isolate) { typedef internal::Object* S; typedef internal::Internals I; - I::CheckInitialized(isolate); + if (!I::IsInitialized(isolate)) return True(); S* slot = I::GetRoot(isolate, I::kTrueValueRootIndex); return Handle(reinterpret_cast(slot)); } @@ -6319,7 +6319,7 @@ Handle True(Isolate* isolate) { Handle False(Isolate* isolate) { typedef internal::Object* S; typedef internal::Internals I; - I::CheckInitialized(isolate); + if (!I::IsInitialized(isolate)) return False(); S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex); return Handle(reinterpret_cast(slot)); } diff --git a/src/api.cc b/src/api.cc index de48424148..4b5c5a9949 100644 --- a/src/api.cc +++ b/src/api.cc @@ -2893,16 +2893,6 @@ Local Value::ToInteger() const { } -#ifdef V8_ENABLE_CHECKS -void i::Internals::CheckInitialized(v8::Isolate* external_isolate) { - i::Isolate* isolate = reinterpret_cast(external_isolate); - ApiCheck(isolate != NULL && isolate->IsInitialized() && !i::V8::IsDead(), - "v8::internal::Internals::CheckInitialized()", - "Isolate is not initialized or V8 has died"); -} -#endif - - void External::CheckCast(v8::Value* that) { if (IsDeadCheck(i::Isolate::Current(), "v8::External::Cast()")) return; ApiCheck(Utils::OpenHandle(that)->IsExternal(), diff --git a/src/isolate.cc b/src/isolate.cc index 564fd7b646..17e80172c5 100644 --- a/src/isolate.cc +++ b/src/isolate.cc @@ -2216,6 +2216,8 @@ bool Isolate::Init(Deserializer* des) { LOG(this, LogCompiledFunctions()); } + CHECK_EQ(static_cast(OFFSET_OF(Isolate, state_)), + Internals::kIsolateStateOffset); CHECK_EQ(static_cast(OFFSET_OF(Isolate, embedder_data_)), Internals::kIsolateEmbedderDataOffset); CHECK_EQ(static_cast(OFFSET_OF(Isolate, heap_.roots_)), diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc index 427118b0e6..d70b762a03 100755 --- a/test/cctest/test-api.cc +++ b/test/cctest/test-api.cc @@ -18796,6 +18796,13 @@ TEST(PrimaryStubCache) { } +static int fatal_error_callback_counter = 0; +static void CountingErrorCallback(const char* location, const char* message) { + printf("CountingErrorCallback(\"%s\", \"%s\")\n", location, message); + fatal_error_callback_counter++; +} + + TEST(StaticGetters) { LocalContext context; i::Factory* factory = i::Isolate::Current()->factory(); @@ -18813,6 +18820,31 @@ TEST(StaticGetters) { i::Handle false_value = factory->false_value(); CHECK(*v8::Utils::OpenHandle(*v8::False()) == *false_value); CHECK(*v8::Utils::OpenHandle(*v8::False(isolate)) == *false_value); + + // Test after-death behavior. + CHECK(i::Internals::IsInitialized(isolate)); + CHECK_EQ(0, fatal_error_callback_counter); + v8::V8::SetFatalErrorHandler(CountingErrorCallback); + v8::Utils::ReportApiFailure("StaticGetters()", "Kill V8"); + i::Isolate::Current()->TearDown(); + CHECK(!i::Internals::IsInitialized(isolate)); + CHECK_EQ(1, fatal_error_callback_counter); + CHECK(v8::Undefined().IsEmpty()); + CHECK_EQ(2, fatal_error_callback_counter); + CHECK(v8::Undefined(isolate).IsEmpty()); + CHECK_EQ(3, fatal_error_callback_counter); + CHECK(v8::Null().IsEmpty()); + CHECK_EQ(4, fatal_error_callback_counter); + CHECK(v8::Null(isolate).IsEmpty()); + CHECK_EQ(5, fatal_error_callback_counter); + CHECK(v8::True().IsEmpty()); + CHECK_EQ(6, fatal_error_callback_counter); + CHECK(v8::True(isolate).IsEmpty()); + CHECK_EQ(7, fatal_error_callback_counter); + CHECK(v8::False().IsEmpty()); + CHECK_EQ(8, fatal_error_callback_counter); + CHECK(v8::False(isolate).IsEmpty()); + CHECK_EQ(9, fatal_error_callback_counter); } @@ -18842,6 +18874,19 @@ TEST(StringEmpty) { i::Handle empty_string = factory->empty_string(); CHECK(*v8::Utils::OpenHandle(*v8::String::Empty()) == *empty_string); CHECK(*v8::Utils::OpenHandle(*v8::String::Empty(isolate)) == *empty_string); + + // Test after-death behavior. + CHECK(i::Internals::IsInitialized(isolate)); + CHECK_EQ(0, fatal_error_callback_counter); + v8::V8::SetFatalErrorHandler(CountingErrorCallback); + v8::Utils::ReportApiFailure("StringEmpty()", "Kill V8"); + i::Isolate::Current()->TearDown(); + CHECK(!i::Internals::IsInitialized(isolate)); + CHECK_EQ(1, fatal_error_callback_counter); + CHECK(v8::String::Empty().IsEmpty()); + CHECK_EQ(2, fatal_error_callback_counter); + CHECK(v8::String::Empty(isolate).IsEmpty()); + CHECK_EQ(3, fatal_error_callback_counter); }