mirror of
https://github.com/darlinghq/darling-JavaScriptCore.git
synced 2025-04-10 02:40:54 +00:00
388 lines
16 KiB
C++
388 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2016-2020 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "GPRInfo.h"
|
|
#include "JSCJSValue.h"
|
|
#include "ResultType.h"
|
|
#include "TagRegistersMode.h"
|
|
|
|
namespace JSC {
|
|
|
|
class CCallHelpers;
|
|
|
|
struct ObservedType {
|
|
constexpr ObservedType(uint8_t bits = TypeEmpty)
|
|
: m_bits(bits)
|
|
{ }
|
|
|
|
constexpr bool sawInt32() const { return m_bits & TypeInt32; }
|
|
constexpr bool isOnlyInt32() const { return m_bits == TypeInt32; }
|
|
constexpr bool sawNumber() const { return m_bits & TypeNumber; }
|
|
constexpr bool isOnlyNumber() const { return m_bits == TypeNumber; }
|
|
constexpr bool sawNonNumber() const { return m_bits & TypeNonNumber; }
|
|
constexpr bool isOnlyNonNumber() const { return m_bits == TypeNonNumber; }
|
|
constexpr bool isEmpty() const { return !m_bits; }
|
|
constexpr uint8_t bits() const { return m_bits; }
|
|
|
|
constexpr ObservedType withInt32() const { return ObservedType(m_bits | TypeInt32); }
|
|
constexpr ObservedType withNumber() const { return ObservedType(m_bits | TypeNumber); }
|
|
constexpr ObservedType withNonNumber() const { return ObservedType(m_bits | TypeNonNumber); }
|
|
constexpr ObservedType withoutNonNumber() const { return ObservedType(m_bits & ~TypeNonNumber); }
|
|
|
|
constexpr bool operator==(const ObservedType& other) const { return m_bits == other.m_bits; }
|
|
|
|
static constexpr uint8_t TypeEmpty = 0x0;
|
|
static constexpr uint8_t TypeInt32 = 0x1;
|
|
static constexpr uint8_t TypeNumber = 0x02;
|
|
static constexpr uint8_t TypeNonNumber = 0x04;
|
|
|
|
static constexpr uint32_t numBitsNeeded = 3;
|
|
|
|
private:
|
|
uint8_t m_bits { 0 };
|
|
};
|
|
|
|
class ObservedResults {
|
|
public:
|
|
enum Tags : uint8_t {
|
|
NonNegZeroDouble = 1 << 0,
|
|
NegZeroDouble = 1 << 1,
|
|
NonNumeric = 1 << 2,
|
|
Int32Overflow = 1 << 3,
|
|
Int52Overflow = 1 << 4,
|
|
HeapBigInt = 1 << 5,
|
|
BigInt32 = 1 << 6,
|
|
};
|
|
static constexpr uint32_t numBitsNeeded = 7;
|
|
|
|
ObservedResults() = default;
|
|
explicit ObservedResults(uint8_t bits)
|
|
: m_bits(bits)
|
|
{ }
|
|
|
|
bool didObserveNonInt32() { return m_bits & (NonNegZeroDouble | NegZeroDouble | NonNumeric | HeapBigInt | BigInt32); }
|
|
bool didObserveDouble() { return m_bits & (NonNegZeroDouble | NegZeroDouble); }
|
|
bool didObserveNonNegZeroDouble() { return m_bits & NonNegZeroDouble; }
|
|
bool didObserveNegZeroDouble() { return m_bits & NegZeroDouble; }
|
|
bool didObserveNonNumeric() { return m_bits & NonNumeric; }
|
|
bool didObserveBigInt() { return m_bits & (HeapBigInt | BigInt32); }
|
|
bool didObserveHeapBigInt() { return m_bits & HeapBigInt; }
|
|
bool didObserveBigInt32() { return m_bits & BigInt32; }
|
|
bool didObserveInt32Overflow() { return m_bits & Int32Overflow; }
|
|
bool didObserveInt52Overflow() { return m_bits & Int52Overflow; }
|
|
|
|
private:
|
|
uint8_t m_bits { 0 };
|
|
};
|
|
|
|
template <typename BitfieldType>
|
|
class ArithProfile {
|
|
public:
|
|
ObservedResults observedResults() const
|
|
{
|
|
return ObservedResults(m_bits & ((1 << ObservedResults::numBitsNeeded) - 1));
|
|
}
|
|
bool didObserveNonInt32() const { return observedResults().didObserveNonInt32();}
|
|
bool didObserveDouble() const { return observedResults().didObserveDouble(); }
|
|
bool didObserveNonNegZeroDouble() const { return observedResults().didObserveNonNegZeroDouble(); }
|
|
bool didObserveNegZeroDouble() const { return observedResults().didObserveNegZeroDouble(); }
|
|
bool didObserveNonNumeric() const { return observedResults().didObserveNonNumeric(); }
|
|
bool didObserveBigInt() const { return observedResults().didObserveBigInt(); }
|
|
bool didObserveHeapBigInt() const { return observedResults().didObserveHeapBigInt(); }
|
|
bool didObserveBigInt32() const { return observedResults().didObserveBigInt32(); }
|
|
bool didObserveInt32Overflow() const { return observedResults().didObserveInt32Overflow(); }
|
|
bool didObserveInt52Overflow() const { return observedResults().didObserveInt52Overflow(); }
|
|
|
|
void setObservedNonNegZeroDouble() { setBit(ObservedResults::NonNegZeroDouble); }
|
|
void setObservedNegZeroDouble() { setBit(ObservedResults::NegZeroDouble); }
|
|
void setObservedNonNumeric() { setBit(ObservedResults::NonNumeric); }
|
|
void setObservedHeapBigInt() { setBit(ObservedResults::HeapBigInt); }
|
|
void setObservedBigInt32() { setBit(ObservedResults::BigInt32); }
|
|
void setObservedInt32Overflow() { setBit(ObservedResults::Int32Overflow); }
|
|
void setObservedInt52Overflow() { setBit(ObservedResults::Int52Overflow); }
|
|
|
|
void observeResult(JSValue value)
|
|
{
|
|
if (value.isInt32())
|
|
return;
|
|
if (value.isNumber()) {
|
|
m_bits |= ObservedResults::Int32Overflow | ObservedResults::Int52Overflow | ObservedResults::NonNegZeroDouble | ObservedResults::NegZeroDouble;
|
|
return;
|
|
}
|
|
if (value.isBigInt32()) {
|
|
m_bits |= ObservedResults::BigInt32;
|
|
return;
|
|
}
|
|
if (value && value.isHeapBigInt()) {
|
|
m_bits |= ObservedResults::HeapBigInt;
|
|
return;
|
|
}
|
|
m_bits |= ObservedResults::NonNumeric;
|
|
}
|
|
|
|
const void* addressOfBits() const { return &m_bits; }
|
|
|
|
#if ENABLE(JIT)
|
|
// Sets (Int32Overflow | Int52Overflow | NonNegZeroDouble | NegZeroDouble) if it sees a
|
|
// double. Sets NonNumeric if it sees a non-numeric.
|
|
void emitObserveResult(CCallHelpers&, JSValueRegs, GPRReg tempGPR, TagRegistersMode = HaveTagRegisters);
|
|
|
|
// Sets (Int32Overflow | Int52Overflow | NonNegZeroDouble | NegZeroDouble).
|
|
bool shouldEmitSetDouble() const;
|
|
void emitSetDouble(CCallHelpers&) const;
|
|
|
|
void emitSetNonNumeric(CCallHelpers&) const;
|
|
bool shouldEmitSetNonNumeric() const;
|
|
|
|
bool shouldEmitSetHeapBigInt() const;
|
|
void emitSetHeapBigInt(CCallHelpers&) const;
|
|
|
|
bool shouldEmitSetBigInt32() const;
|
|
#if USE(BIGINT32)
|
|
void emitSetBigInt32(CCallHelpers&) const;
|
|
#endif
|
|
|
|
void emitUnconditionalSet(CCallHelpers&, BitfieldType) const;
|
|
#endif // ENABLE(JIT)
|
|
|
|
constexpr uint32_t bits() const { return m_bits; }
|
|
|
|
protected:
|
|
ArithProfile() = default;
|
|
|
|
bool hasBits(int mask) const { return m_bits & mask; }
|
|
void setBit(int mask) { m_bits |= mask; }
|
|
|
|
BitfieldType m_bits { 0 }; // We take care to update m_bits only in a single operation. We don't ever store an inconsistent bit representation to it.
|
|
};
|
|
|
|
/* This class stores the following components in 16 bits:
|
|
* - ObservedResults
|
|
* - ObservedType for the argument
|
|
*/
|
|
using UnaryArithProfileBase = uint16_t;
|
|
class UnaryArithProfile : public ArithProfile<UnaryArithProfileBase> {
|
|
static constexpr unsigned argObservedTypeShift = ObservedResults::numBitsNeeded;
|
|
|
|
static_assert(argObservedTypeShift + ObservedType::numBitsNeeded <= sizeof(UnaryArithProfileBase) * 8, "Should fit in the type of the underlying bitfield.");
|
|
|
|
static constexpr UnaryArithProfileBase clearArgObservedTypeBitMask = static_cast<UnaryArithProfileBase>(~(0b111 << argObservedTypeShift));
|
|
|
|
static constexpr UnaryArithProfileBase observedTypeMask = (1 << ObservedType::numBitsNeeded) - 1;
|
|
|
|
public:
|
|
UnaryArithProfile()
|
|
: ArithProfile<UnaryArithProfileBase>()
|
|
{
|
|
ASSERT(argObservedType().isEmpty());
|
|
ASSERT(argObservedType().isEmpty());
|
|
}
|
|
|
|
static constexpr UnaryArithProfileBase observedIntBits()
|
|
{
|
|
constexpr ObservedType observedInt32 { ObservedType().withInt32() };
|
|
constexpr UnaryArithProfileBase bits = observedInt32.bits() << argObservedTypeShift;
|
|
return bits;
|
|
}
|
|
static constexpr UnaryArithProfileBase observedNumberBits()
|
|
{
|
|
constexpr ObservedType observedNumber { ObservedType().withNumber() };
|
|
constexpr UnaryArithProfileBase bits = observedNumber.bits() << argObservedTypeShift;
|
|
return bits;
|
|
}
|
|
|
|
constexpr ObservedType argObservedType() const { return ObservedType((m_bits >> argObservedTypeShift) & observedTypeMask); }
|
|
void setArgObservedType(ObservedType type)
|
|
{
|
|
UnaryArithProfileBase bits = m_bits;
|
|
bits &= clearArgObservedTypeBitMask;
|
|
bits |= type.bits() << argObservedTypeShift;
|
|
m_bits = bits;
|
|
ASSERT(argObservedType() == type);
|
|
}
|
|
|
|
void argSawInt32() { setArgObservedType(argObservedType().withInt32()); }
|
|
void argSawNumber() { setArgObservedType(argObservedType().withNumber()); }
|
|
void argSawNonNumber() { setArgObservedType(argObservedType().withNonNumber()); }
|
|
|
|
void observeArg(JSValue arg)
|
|
{
|
|
UnaryArithProfile newProfile = *this;
|
|
if (arg.isNumber()) {
|
|
if (arg.isInt32())
|
|
newProfile.argSawInt32();
|
|
else
|
|
newProfile.argSawNumber();
|
|
} else
|
|
newProfile.argSawNonNumber();
|
|
|
|
m_bits = newProfile.bits();
|
|
}
|
|
|
|
bool isObservedTypeEmpty()
|
|
{
|
|
return argObservedType().isEmpty();
|
|
}
|
|
|
|
friend class JSC::LLIntOffsetsExtractor;
|
|
};
|
|
|
|
/* This class stores the following components in 16 bits:
|
|
* - ObservedResults
|
|
* - ObservedType for right-hand-side
|
|
* - ObservedType for left-hand-side
|
|
* - a bit used by division to indicate whether a special fast path was taken
|
|
*/
|
|
using BinaryArithProfileBase = uint16_t;
|
|
class BinaryArithProfile : public ArithProfile<BinaryArithProfileBase> {
|
|
static constexpr uint32_t rhsObservedTypeShift = ObservedResults::numBitsNeeded;
|
|
static constexpr uint32_t lhsObservedTypeShift = rhsObservedTypeShift + ObservedType::numBitsNeeded;
|
|
|
|
static_assert(ObservedType::numBitsNeeded == 3, "We make a hard assumption about that here.");
|
|
static constexpr BinaryArithProfileBase clearRhsObservedTypeBitMask = static_cast<BinaryArithProfileBase>(~(0b111 << rhsObservedTypeShift));
|
|
static constexpr BinaryArithProfileBase clearLhsObservedTypeBitMask = static_cast<BinaryArithProfileBase>(~(0b111 << lhsObservedTypeShift));
|
|
|
|
static constexpr BinaryArithProfileBase observedTypeMask = (1 << ObservedType::numBitsNeeded) - 1;
|
|
|
|
public:
|
|
static constexpr BinaryArithProfileBase specialFastPathBit = 1 << (lhsObservedTypeShift + ObservedType::numBitsNeeded);
|
|
static_assert((lhsObservedTypeShift + ObservedType::numBitsNeeded + 1) <= sizeof(BinaryArithProfileBase) * 8, "Should fit in the underlying type.");
|
|
static_assert(!(specialFastPathBit & ~clearLhsObservedTypeBitMask), "These bits should not intersect.");
|
|
static_assert(specialFastPathBit & clearLhsObservedTypeBitMask, "These bits should intersect.");
|
|
static_assert(static_cast<unsigned>(specialFastPathBit) > static_cast<unsigned>(static_cast<BinaryArithProfileBase>(~clearLhsObservedTypeBitMask)), "These bits should not intersect and specialFastPathBit should be a higher bit.");
|
|
|
|
BinaryArithProfile()
|
|
: ArithProfile<BinaryArithProfileBase> ()
|
|
{
|
|
ASSERT(lhsObservedType().isEmpty());
|
|
ASSERT(rhsObservedType().isEmpty());
|
|
}
|
|
|
|
static constexpr BinaryArithProfileBase observedIntIntBits()
|
|
{
|
|
constexpr ObservedType observedInt32 { ObservedType().withInt32() };
|
|
constexpr BinaryArithProfileBase bits = (observedInt32.bits() << lhsObservedTypeShift) | (observedInt32.bits() << rhsObservedTypeShift);
|
|
return bits;
|
|
}
|
|
static constexpr BinaryArithProfileBase observedNumberIntBits()
|
|
{
|
|
constexpr ObservedType observedNumber { ObservedType().withNumber() };
|
|
constexpr ObservedType observedInt32 { ObservedType().withInt32() };
|
|
constexpr BinaryArithProfileBase bits = (observedNumber.bits() << lhsObservedTypeShift) | (observedInt32.bits() << rhsObservedTypeShift);
|
|
return bits;
|
|
}
|
|
static constexpr BinaryArithProfileBase observedIntNumberBits()
|
|
{
|
|
constexpr ObservedType observedNumber { ObservedType().withNumber() };
|
|
constexpr ObservedType observedInt32 { ObservedType().withInt32() };
|
|
constexpr BinaryArithProfileBase bits = (observedInt32.bits() << lhsObservedTypeShift) | (observedNumber.bits() << rhsObservedTypeShift);
|
|
return bits;
|
|
}
|
|
static constexpr BinaryArithProfileBase observedNumberNumberBits()
|
|
{
|
|
constexpr ObservedType observedNumber { ObservedType().withNumber() };
|
|
constexpr BinaryArithProfileBase bits = (observedNumber.bits() << lhsObservedTypeShift) | (observedNumber.bits() << rhsObservedTypeShift);
|
|
return bits;
|
|
}
|
|
|
|
constexpr ObservedType lhsObservedType() const { return ObservedType((m_bits >> lhsObservedTypeShift) & observedTypeMask); }
|
|
constexpr ObservedType rhsObservedType() const { return ObservedType((m_bits >> rhsObservedTypeShift) & observedTypeMask); }
|
|
void setLhsObservedType(ObservedType type)
|
|
{
|
|
BinaryArithProfileBase bits = m_bits;
|
|
bits &= clearLhsObservedTypeBitMask;
|
|
bits |= type.bits() << lhsObservedTypeShift;
|
|
m_bits = bits;
|
|
ASSERT(lhsObservedType() == type);
|
|
}
|
|
|
|
void setRhsObservedType(ObservedType type)
|
|
{
|
|
BinaryArithProfileBase bits = m_bits;
|
|
bits &= clearRhsObservedTypeBitMask;
|
|
bits |= type.bits() << rhsObservedTypeShift;
|
|
m_bits = bits;
|
|
ASSERT(rhsObservedType() == type);
|
|
}
|
|
|
|
bool tookSpecialFastPath() const { return m_bits & specialFastPathBit; }
|
|
|
|
void lhsSawInt32() { setLhsObservedType(lhsObservedType().withInt32()); }
|
|
void lhsSawNumber() { setLhsObservedType(lhsObservedType().withNumber()); }
|
|
void lhsSawNonNumber() { setLhsObservedType(lhsObservedType().withNonNumber()); }
|
|
void rhsSawInt32() { setRhsObservedType(rhsObservedType().withInt32()); }
|
|
void rhsSawNumber() { setRhsObservedType(rhsObservedType().withNumber()); }
|
|
void rhsSawNonNumber() { setRhsObservedType(rhsObservedType().withNonNumber()); }
|
|
|
|
void observeLHS(JSValue lhs)
|
|
{
|
|
BinaryArithProfile newProfile = *this;
|
|
if (lhs.isNumber()) {
|
|
if (lhs.isInt32())
|
|
newProfile.lhsSawInt32();
|
|
else
|
|
newProfile.lhsSawNumber();
|
|
} else
|
|
newProfile.lhsSawNonNumber();
|
|
|
|
m_bits = newProfile.bits();
|
|
}
|
|
|
|
void observeLHSAndRHS(JSValue lhs, JSValue rhs)
|
|
{
|
|
observeLHS(lhs);
|
|
|
|
BinaryArithProfile newProfile = *this;
|
|
if (rhs.isNumber()) {
|
|
if (rhs.isInt32())
|
|
newProfile.rhsSawInt32();
|
|
else
|
|
newProfile.rhsSawNumber();
|
|
} else
|
|
newProfile.rhsSawNonNumber();
|
|
|
|
m_bits = newProfile.bits();
|
|
}
|
|
|
|
bool isObservedTypeEmpty()
|
|
{
|
|
return lhsObservedType().isEmpty() && rhsObservedType().isEmpty();
|
|
}
|
|
|
|
friend class JSC::LLIntOffsetsExtractor;
|
|
};
|
|
|
|
} // namespace JSC
|
|
|
|
namespace WTF {
|
|
|
|
void printInternal(PrintStream&, const JSC::UnaryArithProfile&);
|
|
void printInternal(PrintStream&, const JSC::BinaryArithProfile&);
|
|
void printInternal(PrintStream&, const JSC::ObservedType&);
|
|
|
|
} // namespace WTF
|