Commit b74e0add authored by Alberto Garcia's avatar Alberto Garcia
Browse files

New upstream version 2.16.2

parent e699f4cc
......@@ -14,7 +14,7 @@
<div class="titlepage">
<div>
<div><table class="navigation" id="top" width="100%" cellpadding="2" cellspacing="0"><tr><th valign="middle"><p class="title">WebKit2GTK+ Reference Manual</p></th></tr></table></div>
<div><p class="releaseinfo">for WebKit2GTK+ 2.16.1</p></div>
<div><p class="releaseinfo">for WebKit2GTK+ 2.16.2</p></div>
</div>
<hr>
</div>
......
......@@ -177,7 +177,7 @@ against at application run time.</p>
<hr>
<div class="refsect2">
<a name="WEBKIT-MICRO-VERSION:CAPS"></a><h3>WEBKIT_MICRO_VERSION</h3>
<pre class="programlisting">#define WEBKIT_MICRO_VERSION (1)
<pre class="programlisting">#define WEBKIT_MICRO_VERSION (2)
</pre>
<p>Like <a class="link" href="webkit2gtk-4.0-WebKitVersion.html#webkit-get-micro-version" title="webkit_get_micro_version ()"><code class="function">webkit_get_micro_version()</code></a>, but from the headers used at
application compile time, rather than from the library linked
......
......@@ -14,7 +14,7 @@
<div class="titlepage">
<div>
<div><table class="navigation" id="top" width="100%" cellpadding="2" cellspacing="0"><tr><th valign="middle"><p class="title">WebKitDOMGTK+ Reference Manual</p></th></tr></table></div>
<div><p class="releaseinfo">for WebKitDOMGTK+ 2.16.1</p></div>
<div><p class="releaseinfo">for WebKitDOMGTK+ 2.16.2</p></div>
</div>
<hr>
</div>
......
==================
WebKitGTK+ 2.16.2
==================
- Update user agent quirks to make Youtube and new Google login page work.
- Fix rendering of animated PNGs.
- Fix playing of some live streams.
- Update several web inspector icons.
- Fix the build with NPAPI plugins enabled but X11 disabled.
- Fix the build with OpenGL disabled.
- Fix several crashes and rendering issues.
==================
WebKitGTK+ 2.16.1
==================
......
......@@ -37,7 +37,7 @@ using namespace WTF::Unicode;
JSStringRef JSStringCreateWithCharacters(const JSChar* chars, size_t numChars)
{
initializeThreading();
return &OpaqueJSString::create(chars, numChars).leakRef();
return &OpaqueJSString::create(reinterpret_cast<const UChar*>(chars), numChars).leakRef();
}
JSStringRef JSStringCreateWithUTF8CString(const char* string)
......@@ -62,7 +62,7 @@ JSStringRef JSStringCreateWithUTF8CString(const char* string)
JSStringRef JSStringCreateWithCharactersNoCopy(const JSChar* chars, size_t numChars)
{
initializeThreading();
return OpaqueJSString::create(StringImpl::createWithoutCopying(chars, numChars)).leakRef();
return OpaqueJSString::create(StringImpl::createWithoutCopying(reinterpret_cast<const UChar*>(chars), numChars)).leakRef();
}
JSStringRef JSStringRetain(JSStringRef string)
......@@ -87,7 +87,7 @@ const JSChar* JSStringGetCharactersPtr(JSStringRef string)
{
if (!string)
return nullptr;
return string->characters();
return reinterpret_cast<const JSChar*>(string->characters());
}
size_t JSStringGetMaximumUTF8CStringSize(JSStringRef string)
......
......@@ -33,6 +33,7 @@
#include <setjmp.h>
#include <stdlib.h>
#include <wtf/MainThread.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/StdLibExtras.h>
#if OS(DARWIN)
......@@ -69,14 +70,14 @@
// We use SIGUSR2 to suspend and resume machine threads in JavaScriptCore.
static const int SigThreadSuspendResume = SIGUSR2;
static StaticLock globalSignalLock;
thread_local static std::atomic<JSC::MachineThreads::Thread*> threadLocalCurrentThread;
thread_local static std::atomic<JSC::MachineThreads::ThreadData*> threadLocalCurrentThread { nullptr };
static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
{
// Touching thread local atomic types from signal handlers is allowed.
JSC::MachineThreads::Thread* thread = threadLocalCurrentThread.load();
JSC::MachineThreads::ThreadData* threadData = threadLocalCurrentThread.load();
if (thread->suspended.load(std::memory_order_acquire)) {
if (threadData->suspended.load(std::memory_order_acquire)) {
// This is signal handler invocation that is intended to be used to resume sigsuspend.
// So this handler invocation itself should not process.
//
......@@ -88,9 +89,9 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
ucontext_t* userContext = static_cast<ucontext_t*>(ucontext);
#if CPU(PPC)
thread->suspendedMachineContext = *userContext->uc_mcontext.uc_regs;
threadData->suspendedMachineContext = *userContext->uc_mcontext.uc_regs;
#else
thread->suspendedMachineContext = userContext->uc_mcontext;
threadData->suspendedMachineContext = userContext->uc_mcontext;
#endif
// Allow suspend caller to see that this thread is suspended.
......@@ -99,7 +100,7 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
//
// And sem_post emits memory barrier that ensures that suspendedMachineContext is correctly saved.
// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_11
sem_post(&thread->semaphoreForSuspendResume);
sem_post(&threadData->semaphoreForSuspendResume);
// Reaching here, SigThreadSuspendResume is blocked in this handler (this is configured by sigaction's sa_mask).
// So before calling sigsuspend, SigThreadSuspendResume to this thread is deferred. This ensures that the handler is not executed recursively.
......@@ -109,7 +110,7 @@ static void pthreadSignalHandlerSuspendResume(int, siginfo_t*, void* ucontext)
sigsuspend(&blockedSignalSet);
// Allow resume caller to see that this thread is resumed.
sem_post(&thread->semaphoreForSuspendResume);
sem_post(&threadData->semaphoreForSuspendResume);
}
#endif // USE(PTHREADS) && !OS(WINDOWS) && !OS(DARWIN)
......@@ -215,18 +216,29 @@ MachineThreads::~MachineThreads()
}
}
static MachineThreads::ThreadData* threadData()
{
static NeverDestroyed<ThreadSpecific<MachineThreads::ThreadData, CanBeGCThread::True>> threadData;
return threadData.get();
}
MachineThreads::Thread::Thread(ThreadData* threadData)
: data(threadData)
{
ASSERT(threadData);
}
Thread* MachineThreads::Thread::createForCurrentThread()
{
auto stackBounds = wtfThreadData().stack();
return new Thread(getCurrentPlatformThread(), stackBounds.origin(), stackBounds.end());
return new Thread(threadData());
}
bool MachineThreads::Thread::operator==(const PlatformThread& other) const
{
#if OS(DARWIN) || OS(WINDOWS)
return platformThread == other;
return data->platformThread == other;
#elif USE(PTHREADS)
return !!pthread_equal(platformThread, other);
return !!pthread_equal(data->platformThread, other);
#else
#error Need a way to compare threads on this platform
#endif
......@@ -325,11 +337,13 @@ void MachineThreads::gatherFromCurrentThread(ConservativeRoots& conservativeRoot
conservativeRoots.add(currentThreadState.stackTop, currentThreadState.stackOrigin, jitStubRoutines, codeBlocks);
}
MachineThreads::Thread::Thread(const PlatformThread& platThread, void* base, void* end)
: platformThread(platThread)
, stackBase(base)
, stackEnd(end)
MachineThreads::ThreadData::ThreadData()
{
auto stackBounds = wtfThreadData().stack();
platformThread = getCurrentPlatformThread();
stackBase = stackBounds.origin();
stackEnd = stackBounds.end();
#if OS(WINDOWS)
ASSERT(platformThread == GetCurrentThreadId());
bool isSuccessful =
......@@ -362,7 +376,7 @@ MachineThreads::Thread::Thread(const PlatformThread& platThread, void* base, voi
#endif
}
MachineThreads::Thread::~Thread()
MachineThreads::ThreadData::~ThreadData()
{
#if OS(WINDOWS)
CloseHandle(platformThreadHandle);
......@@ -371,7 +385,7 @@ MachineThreads::Thread::~Thread()
#endif
}
bool MachineThreads::Thread::suspend()
bool MachineThreads::ThreadData::suspend()
{
#if OS(DARWIN)
kern_return_t result = thread_suspend(platformThread);
......@@ -408,7 +422,7 @@ bool MachineThreads::Thread::suspend()
#endif
}
void MachineThreads::Thread::resume()
void MachineThreads::ThreadData::resume()
{
#if OS(DARWIN)
thread_resume(platformThread);
......@@ -439,9 +453,9 @@ void MachineThreads::Thread::resume()
#endif
}
size_t MachineThreads::Thread::getRegisters(Thread::Registers& registers)
size_t MachineThreads::ThreadData::getRegisters(ThreadData::Registers& registers)
{
Thread::Registers::PlatformRegisters& regs = registers.regs;
ThreadData::Registers::PlatformRegisters& regs = registers.regs;
#if OS(DARWIN)
#if CPU(X86)
unsigned user_count = sizeof(regs)/sizeof(int);
......@@ -496,7 +510,7 @@ size_t MachineThreads::Thread::getRegisters(Thread::Registers& registers)
#endif
}
void* MachineThreads::Thread::Registers::stackPointer() const
void* MachineThreads::ThreadData::Registers::stackPointer() const
{
#if OS(DARWIN)
......@@ -601,7 +615,7 @@ void* MachineThreads::Thread::Registers::stackPointer() const
}
#if ENABLE(SAMPLING_PROFILER)
void* MachineThreads::Thread::Registers::framePointer() const
void* MachineThreads::ThreadData::Registers::framePointer() const
{
#if OS(DARWIN)
......@@ -684,7 +698,7 @@ void* MachineThreads::Thread::Registers::framePointer() const
#endif
}
void* MachineThreads::Thread::Registers::instructionPointer() const
void* MachineThreads::ThreadData::Registers::instructionPointer() const
{
#if OS(DARWIN)
......@@ -765,7 +779,8 @@ void* MachineThreads::Thread::Registers::instructionPointer() const
#error Need a way to get the instruction pointer for another thread on this platform
#endif
}
void* MachineThreads::Thread::Registers::llintPC() const
void* MachineThreads::ThreadData::Registers::llintPC() const
{
// LLInt uses regT4 as PC.
#if OS(DARWIN)
......@@ -858,9 +873,9 @@ void* MachineThreads::Thread::Registers::llintPC() const
}
#endif // ENABLE(SAMPLING_PROFILER)
void MachineThreads::Thread::freeRegisters(Thread::Registers& registers)
void MachineThreads::ThreadData::freeRegisters(ThreadData::Registers& registers)
{
Thread::Registers::PlatformRegisters& regs = registers.regs;
ThreadData::Registers::PlatformRegisters& regs = registers.regs;
#if USE(PTHREADS) && !OS(WINDOWS) && !OS(DARWIN)
pthread_attr_destroy(&regs.attribute);
#else
......@@ -883,7 +898,7 @@ static inline int osRedZoneAdjustment()
return redZoneAdjustment;
}
std::pair<void*, size_t> MachineThreads::Thread::captureStack(void* stackTop)
std::pair<void*, size_t> MachineThreads::ThreadData::captureStack(void* stackTop)
{
char* begin = reinterpret_cast_ptr<char*>(stackBase);
char* end = bitwise_cast<char*>(WTF::roundUpToMultipleOf<sizeof(void*)>(reinterpret_cast<uintptr_t>(stackTop)));
......@@ -971,12 +986,12 @@ bool MachineThreads::tryCopyOtherThreadStacks(LockHolder&, void* buffer, size_t
}
// Re-do the suspension to get the actual failure result for logging.
kern_return_t error = thread_suspend(thread->platformThread);
kern_return_t error = thread_suspend(thread->platformThread());
ASSERT(error != KERN_SUCCESS);
WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION,
"JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p] platformThread %p.",
error, index, numberOfThreads, thread, reinterpret_cast<void*>(thread->platformThread));
error, index, numberOfThreads, thread, reinterpret_cast<void*>(thread->platformThread()));
// Put the invalid thread on the threadsToBeDeleted list.
// We can't just delete it here because we have suspended other
......
......@@ -74,14 +74,13 @@ public:
JS_EXPORT_PRIVATE void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
class Thread {
class ThreadData {
WTF_MAKE_FAST_ALLOCATED;
Thread(const PlatformThread& platThread, void* base, void* end);
public:
~Thread();
ThreadData();
~ThreadData();
static Thread* createForCurrentThread();
static ThreadData* createForCurrentThread();
struct Registers {
void* stackPointer() const;
......@@ -118,12 +117,9 @@ public:
#else
#error Need a thread register struct for this platform
#endif
PlatformRegisters regs;
};
bool operator==(const PlatformThread& other) const;
bool operator!=(const PlatformThread& other) const { return !(*this == other); }
bool suspend();
void resume();
......@@ -131,7 +127,6 @@ public:
void freeRegisters(Registers&);
std::pair<void*, size_t> captureStack(void* stackTop);
Thread* next;
PlatformThread platformThread;
void* stackBase;
void* stackEnd;
......@@ -145,6 +140,32 @@ public:
#endif
};
class Thread {
WTF_MAKE_FAST_ALLOCATED;
Thread(ThreadData*);
public:
using Registers = ThreadData::Registers;
static Thread* createForCurrentThread();
bool operator==(const PlatformThread& other) const;
bool operator!=(const PlatformThread& other) const { return !(*this == other); }
bool suspend() { return data->suspend(); }
void resume() { data->resume(); }
size_t getRegisters(Registers& regs) { return data->getRegisters(regs); }
void freeRegisters(Registers& regs) { data->freeRegisters(regs); }
std::pair<void*, size_t> captureStack(void* stackTop) { return data->captureStack(stackTop); }
const PlatformThread& platformThread() { return data->platformThread; }
void* stackBase() const { return data->stackBase; }
void* stackEnd() const { return data->stackEnd; }
Thread* next;
ThreadData* data;
};
Lock& getLock() { return m_registeredThreadsMutex; }
Thread* threadsListHead(const LockHolder&) const { ASSERT(m_registeredThreadsMutex.isLocked()); return m_registeredThreads; }
Thread* machineThreadForCurrentThread();
......
......@@ -94,6 +94,7 @@ end
ARM_EXTRA_GPRS = [SpecialRegister.new("r6"), SpecialRegister.new("r10"), SpecialRegister.new("r12")]
ARM_EXTRA_FPRS = [SpecialRegister.new("d7")]
ARM_SCRATCH_FPR = SpecialRegister.new("d6")
OS_DARWIN = ((RUBY_PLATFORM =~ /darwin/i) != nil)
def armMoveImmediate(value, register)
# Currently we only handle the simple cases, and fall back to mov/movt for the complex ones.
......@@ -568,7 +569,11 @@ class Instruction
end
when "call"
if operands[0].label?
$asm.puts "blx #{operands[0].asmLabel}"
if OS_DARWIN
$asm.puts "blx #{operands[0].asmLabel}"
else
$asm.puts "bl #{operands[0].asmLabel}"
end
else
$asm.puts "blx #{operands[0].armOperand}"
end
......
......@@ -107,7 +107,8 @@ String formatDateTime(const GregorianDateTime& t, DateTimeFormat format, bool as
#if OS(WINDOWS)
TIME_ZONE_INFORMATION timeZoneInformation;
GetTimeZoneInformation(&timeZoneInformation);
const WCHAR* timeZoneName = t.isDST() ? timeZoneInformation.DaylightName : timeZoneInformation.StandardName;
const WCHAR* winTimeZoneName = t.isDST() ? timeZoneInformation.DaylightName : timeZoneInformation.StandardName;
String timeZoneName(reinterpret_cast<const UChar*>(winTimeZoneName));
#else
struct tm gtm = t;
char timeZoneName[70];
......@@ -115,11 +116,7 @@ String formatDateTime(const GregorianDateTime& t, DateTimeFormat format, bool as
#endif
if (timeZoneName[0]) {
builder.appendLiteral(" (");
#if OS(WINDOWS)
builder.append(String(timeZoneName));
#else
builder.append(timeZoneName);
#endif
builder.append(')');
}
}
......
......@@ -469,67 +469,7 @@ int32_t JIT_OPERATION operationToInt32(double value)
int32_t JIT_OPERATION operationToInt32SensibleSlow(double number)
{
// This function is specialized `operationToInt32` for the slow case of
// the sensible double-to-int32 operation. It is available in x86.
//
// In the sensible double-to-int32, first we attempt to truncate the
// double value to int32 by using cvttsd2si_rr.
// According to the Intel's manual, cvttsd2si perform the following truncate
// operation.
//
// If src = NaN, +-Inf, or |(src)rz| > 0x7fffffff and (src)rz != 0x80000000,
// the result becomes 0x80000000. Otherwise, the operation succeeds.
// Note that ()rz is rouding towards zero.
//
// We call this slow case function when the above cvttsd2si fails. We check
// this condition by performing `result == 0x80000000`. So this function only
// accepts the following numbers.
//
// NaN, +-Inf, |(src)rz| > 0x7fffffff.
//
// As a result, the exp of the double is always >= 31.
// This condition simplifies and speeds up the toInt32 implementation.
int64_t bits = WTF::bitwise_cast<int64_t>(number);
int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
// If exponent < 0 there will be no bits to the left of the decimal point
// after rounding; if the exponent is > 83 then no bits of precision can be
// left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
// of fractional precision).
// Note this case handles 0, -0, and all infinite, NaN, & denormal value.
// If exp < 0, truncate operation succeeds. So this function does not
// encounter that case. If exp > 83, it means exp >= 84. In that case,
// the following operation produces 0 for the result.
ASSERT(exp >= 0);
// Select the appropriate 32-bits from the floating point mantissa. If the
// exponent is 52 then the bits we need to select are already aligned to the
// lowest bits of the 64-bit integer representation of the number, no need
// to shift. If the exponent is greater than 52 we need to shift the value
// left by (exp - 52), if the value is less than 52 we need to shift right
// accordingly.
int32_t result = (exp > 52)
? static_cast<int32_t>(bits << (exp - 52))
: static_cast<int32_t>(bits >> (52 - exp));
// IEEE-754 double precision values are stored omitting an implicit 1 before
// the decimal point; we need to reinsert this now. We may also the shifted
// invalid bits into the result that are not a part of the mantissa (the sign
// and exponent bits from the floatingpoint representation); mask these out.
//
// The important observation is that exp is always >= 31. So the above case
// is needed to be cared only when the exp == 31.
ASSERT(exp >= 31);
if (exp == 31) {
int32_t missingOne = 1 << exp;
result &= (missingOne - 1);
result += missingOne;
}
// If the input value was negative (we could test either 'number' or 'bits',
// but testing 'bits' is likely faster) invert the result appropriately.
return bits < 0 ? -result : result;
return toInt32Internal<ToInt32Mode::AfterSensibleConversionAttempt>(number);
}
#if HAVE(ARM_IDIV_INSTRUCTIONS)
......
......@@ -73,9 +73,14 @@ inline int clz32(uint32_t number)
//
// The operation can be described as round towards zero, then select the 32 least
// bits of the resulting value in 2s-complement representation.
ALWAYS_INLINE int32_t toInt32(double number)
enum ToInt32Mode {
Generic,
AfterSensibleConversionAttempt,
};
template<ToInt32Mode Mode>
ALWAYS_INLINE int32_t toInt32Internal(double number)
{
int64_t bits = WTF::bitwise_cast<int64_t>(number);
uint64_t bits = WTF::bitwise_cast<uint64_t>(number);
int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
// If exponent < 0 there will be no bits to the left of the decimal point
......@@ -83,7 +88,14 @@ ALWAYS_INLINE int32_t toInt32(double number)
// left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
// of fractional precision).
// Note this case handles 0, -0, and all infinite, NaN, & denormal value.
if (exp < 0 || exp > 83)
// We need to check exp > 83 because:
// 1. exp may be used as a left shift value below in (exp - 52), and
// 2. Left shift amounts that exceed 31 results in undefined behavior. See:
// http://en.cppreference.com/w/cpp/language/operator_arithmetic#Bitwise_shift_operators
//
// Using an unsigned comparison here also gives us a exp < 0 check for free.
if (static_cast<uint32_t>(exp) > 83u)
return 0;
// Select the appropriate 32-bits from the floating point mantissa. If the
......@@ -92,23 +104,61 @@ ALWAYS_INLINE int32_t toInt32(double number)
// to shift. If the exponent is greater than 52 we need to shift the value
// left by (exp - 52), if the value is less than 52 we need to shift right
// accordingly.
int32_t result = (exp > 52)
? static_cast<int32_t>(bits << (exp - 52))
: static_cast<int32_t>(bits >> (52 - exp));
uint32_t result = (exp > 52)
? static_cast<uint32_t>(bits << (exp - 52))
: static_cast<uint32_t>(bits >> (52 - exp));
// IEEE-754 double precision values are stored omitting an implicit 1 before
// the decimal point; we need to reinsert this now. We may also the shifted
// invalid bits into the result that are not a part of the mantissa (the sign
// and exponent bits from the floatingpoint representation); mask these out.
if (exp < 32) {
int32_t missingOne = 1 << exp;
result &= missingOne - 1;
result += missingOne;
// Note that missingOne should be held as uint32_t since ((1 << 31) - 1) causes
// int32_t overflow.
if (Mode == ToInt32Mode::AfterSensibleConversionAttempt) {
if (exp == 31) {
// This is an optimization for when toInt32() is called in the slow path
// of a JIT operation. Currently, this optimization is only applicable for
// x86 ports. This optimization offers 5% performance improvement in
// kraken-crypto-pbkdf2.
//
// On x86, the fast path does a sensible double-to-int32 conversion, by
// first attempting to truncate the double value to int32 using the
// cvttsd2si_rr instruction. According to Intel's manual, cvttsd2si performs
// the following truncate operation:
//
// If src = NaN, +-Inf, or |(src)rz| > 0x7fffffff and (src)rz != 0x80000000,
// then the result becomes 0x80000000. Otherwise, the operation succeeds.
//
// Note that the ()rz notation means rounding towards zero.
// We'll call the slow case function only when the above cvttsd2si fails. The
// JIT code checks for fast path failure by checking if result == 0x80000000.
// Hence, the slow path will only see the following possible set of numbers:
//
// NaN, +-Inf, or |(src)rz| > 0x7fffffff.
//
// As a result, the exp of the double is always >= 31. We can take advantage
// of this by specifically checking for (exp == 31) and give the compiler a
// chance to constant fold the operations below.
const constexpr uint32_t missingOne = 1U << 31;
result &= missingOne - 1;
result += missingOne;
}
} else {
if (exp < 32) {
const uint32_t missingOne = 1U << exp;
result &= missingOne - 1;
result += missingOne;
}
}
// If the input value was negative (we could test either 'number' or 'bits',
// but testing 'bits' is likely faster) invert the result appropriately.
return bits < 0 ? -result : result;
return static_cast<int64_t>(bits) < 0 ? -static_cast<int32_t>(result) : static_cast<int32_t>(result);
}
ALWAYS_INLINE int32_t toInt32(double number)
{
return toInt32Internal<ToInt32Mode::Generic>(number);
}
// This implements ToUInt32, defined in ECMA-262 9.6.
......
......@@ -169,8 +169,8 @@ protected:
{
uint8_t* fpCast = bitwise_cast<uint8_t*>(exec);
for (MachineThreads::Thread* thread = m_vm.heap.machineThreads().threadsListHead(m_machineThreadsLocker); thread; thread = thread->next) {
uint8_t* stackBase = static_cast<uint8_t*>(thread->stackBase);
uint8_t* stackLimit = static_cast<uint8_t*>(thread->stackEnd);
uint8_t* stackBase = static_cast<uint8_t*>(thread->stackBase());
uint8_t* stackLimit = static_cast<uint8_t*>(thread->stackEnd());
RELEASE_ASSERT(stackBase);
RELEASE_ASSERT(stackLimit);
if (fpCast <= stackBase && fpCast >= stackLimit)
......
......@@ -272,6 +272,12 @@ set(WTF_SOURCES
set(WTF_INCLUDE_DIRECTORIES
"${BMALLOC_DIR}"
"${WTF_DIR}"
"${CMAKE_BINARY_DIR}"
"${DERIVED_SOURCES_DIR}"
"${THIRDPARTY_DIR}"
)
set(WTF_PRIVATE_INCLUDE_DIRECTORIES
"${WTF_DIR}/wtf"
"${WTF_DIR}/wtf/dtoa"
"${WTF_DIR}/wtf/persistence"
......@@ -279,9 +285,6 @@ set(WTF_INCLUDE_DIRECTORIES