blob: 261a26b0ecd862257e5bf1c9ad75cb9f42a62902 [file] [log] [blame]
/*
* Copyright (C) 2011, 2012 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.
* 3. Neither the name of Apple Computer, Inc. ("Apple") 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 APPLE AND ITS 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 APPLE OR ITS 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 SpeculatedType_h
#define SpeculatedType_h
#include "JSValue.h"
namespace JSC {
class Structure;
typedef uint32_t SpeculatedType;
static const SpeculatedType SpecNone = 0x00000000; // We don't know anything yet.
static const SpeculatedType SpecFinalObject = 0x00000001; // It's definitely a JSFinalObject.
static const SpeculatedType SpecArray = 0x00000002; // It's definitely a JSArray.
static const SpeculatedType SpecFunction = 0x00000008; // It's definitely a JSFunction or one of its subclasses.
static const SpeculatedType SpecInt8Array = 0x00000010; // It's definitely an Int8Array or one of its subclasses.
static const SpeculatedType SpecInt16Array = 0x00000020; // It's definitely an Int16Array or one of its subclasses.
static const SpeculatedType SpecInt32Array = 0x00000040; // It's definitely an Int32Array or one of its subclasses.
static const SpeculatedType SpecUint8Array = 0x00000080; // It's definitely an Uint8Array or one of its subclasses.
static const SpeculatedType SpecUint8ClampedArray = 0x00000100; // It's definitely an Uint8ClampedArray or one of its subclasses.
static const SpeculatedType SpecUint16Array = 0x00000200; // It's definitely an Uint16Array or one of its subclasses.
static const SpeculatedType SpecUint32Array = 0x00000400; // It's definitely an Uint32Array or one of its subclasses.
static const SpeculatedType SpecFloat32Array = 0x00000800; // It's definitely an Uint16Array or one of its subclasses.
static const SpeculatedType SpecFloat64Array = 0x00001000; // It's definitely an Uint16Array or one of its subclasses.
static const SpeculatedType SpecMyArguments = 0x00002000; // It's definitely an Arguments object, and it's definitely the one for my current frame.
static const SpeculatedType SpecForeignArguments = 0x00004000; // It's definitely an Arguments object, and it's definitely not mine.
static const SpeculatedType SpecArguments = 0x00006000; // It's definitely an Arguments object.
static const SpeculatedType SpecObjectOther = 0x00008000; // It's definitely an object but not JSFinalObject, JSArray, or JSFunction.
static const SpeculatedType SpecObjectMask = 0x0000ffff; // Bitmask used for testing for any kind of object prediction.
static const SpeculatedType SpecString = 0x00010000; // It's definitely a JSString.
static const SpeculatedType SpecCellOther = 0x00020000; // It's definitely a JSCell but not a subclass of JSObject and definitely not a JSString.
static const SpeculatedType SpecCell = 0x0003ffff; // It's definitely a JSCell.
static const SpeculatedType SpecInt32 = 0x00800000; // It's definitely an Int32.
static const SpeculatedType SpecDoubleReal = 0x01000000; // It's definitely a non-NaN double.
static const SpeculatedType SpecDoubleNaN = 0x02000000; // It's definitely a NaN.
static const SpeculatedType SpecDouble = 0x03000000; // It's either a non-NaN or a NaN double.
static const SpeculatedType SpecRealNumber = 0x01800000; // It's either an Int32 or a DoubleReal.
static const SpeculatedType SpecNumber = 0x03800000; // It's either an Int32 or a Double.
static const SpeculatedType SpecBoolean = 0x04000000; // It's definitely a Boolean.
static const SpeculatedType SpecOther = 0x08000000; // It's definitely none of the above.
static const SpeculatedType SpecTop = 0x0fffffff; // It can be any of the above.
static const SpeculatedType SpecEmpty = 0x10000000; // It's definitely an empty value marker.
static const SpeculatedType SpecEmptyOrTop = 0x1fffffff; // It can be any of the above.
static const SpeculatedType FixedIndexedStorageMask = SpecInt8Array | SpecInt16Array | SpecInt32Array | SpecUint8Array | SpecUint8ClampedArray | SpecUint16Array | SpecUint32Array | SpecFloat32Array | SpecFloat64Array;
typedef bool (*SpeculatedTypeChecker)(SpeculatedType);
// Dummy prediction checker, only useful if someone insists on requiring a prediction checker.
inline bool isAnySpeculation(SpeculatedType)
{
return true;
}
inline bool isCellSpeculation(SpeculatedType value)
{
return !!(value & SpecCell) && !(value & ~SpecCell);
}
inline bool isNonStringCellSpeculation(SpeculatedType value)
{
return !!(value & (SpecCell & ~SpecString)) && !(value & ~(SpecCell & ~SpecString));
}
inline bool isNonStringCellOrOtherSpeculation(SpeculatedType value)
{
return !!(value & ((SpecCell & ~SpecString) | SpecOther)) && !(value & ~((SpecCell & ~SpecString) | SpecOther));
}
inline bool isObjectSpeculation(SpeculatedType value)
{
return !!(value & SpecObjectMask) && !(value & ~SpecObjectMask);
}
inline bool isFinalObjectSpeculation(SpeculatedType value)
{
return value == SpecFinalObject;
}
inline bool isFinalObjectOrOtherSpeculation(SpeculatedType value)
{
return !!(value & (SpecFinalObject | SpecOther)) && !(value & ~(SpecFinalObject | SpecOther));
}
inline bool isFixedIndexedStorageObjectSpeculation(SpeculatedType value)
{
return !!value && (value & FixedIndexedStorageMask) == value;
}
inline bool isStringSpeculation(SpeculatedType value)
{
return value == SpecString;
}
inline bool isArraySpeculation(SpeculatedType value)
{
return value == SpecArray;
}
inline bool isFunctionSpeculation(SpeculatedType value)
{
return value == SpecFunction;
}
inline bool isInt8ArraySpeculation(SpeculatedType value)
{
return value == SpecInt8Array;
}
inline bool isInt16ArraySpeculation(SpeculatedType value)
{
return value == SpecInt16Array;
}
inline bool isInt32ArraySpeculation(SpeculatedType value)
{
return value == SpecInt32Array;
}
inline bool isUint8ArraySpeculation(SpeculatedType value)
{
return value == SpecUint8Array;
}
inline bool isUint8ClampedArraySpeculation(SpeculatedType value)
{
return value == SpecUint8ClampedArray;
}
inline bool isUint16ArraySpeculation(SpeculatedType value)
{
return value == SpecUint16Array;
}
inline bool isUint32ArraySpeculation(SpeculatedType value)
{
return value == SpecUint32Array;
}
inline bool isFloat32ArraySpeculation(SpeculatedType value)
{
return value == SpecFloat32Array;
}
inline bool isFloat64ArraySpeculation(SpeculatedType value)
{
return value == SpecFloat64Array;
}
inline bool isArgumentsSpeculation(SpeculatedType value)
{
return !!value && (value & SpecArguments) == value;
}
inline bool isActionableIntMutableArraySpeculation(SpeculatedType value)
{
return isInt8ArraySpeculation(value)
|| isInt16ArraySpeculation(value)
|| isInt32ArraySpeculation(value)
|| isUint8ArraySpeculation(value)
|| isUint8ClampedArraySpeculation(value)
|| isUint16ArraySpeculation(value)
|| isUint32ArraySpeculation(value);
}
inline bool isActionableFloatMutableArraySpeculation(SpeculatedType value)
{
return isFloat32ArraySpeculation(value)
|| isFloat64ArraySpeculation(value);
}
inline bool isActionableTypedMutableArraySpeculation(SpeculatedType value)
{
return isActionableIntMutableArraySpeculation(value)
|| isActionableFloatMutableArraySpeculation(value);
}
inline bool isActionableMutableArraySpeculation(SpeculatedType value)
{
return isArraySpeculation(value)
|| isArgumentsSpeculation(value)
|| isActionableTypedMutableArraySpeculation(value);
}
inline bool isActionableArraySpeculation(SpeculatedType value)
{
return isStringSpeculation(value)
|| isActionableMutableArraySpeculation(value);
}
inline bool isArrayOrOtherSpeculation(SpeculatedType value)
{
return !!(value & (SpecArray | SpecOther)) && !(value & ~(SpecArray | SpecOther));
}
inline bool isMyArgumentsSpeculation(SpeculatedType value)
{
return value == SpecMyArguments;
}
inline bool isInt32Speculation(SpeculatedType value)
{
return value == SpecInt32;
}
inline bool isInt32SpeculationForArithmetic(SpeculatedType value)
{
return !(value & SpecDouble);
}
inline bool isInt32SpeculationExpectingDefined(SpeculatedType value)
{
return isInt32Speculation(value & ~SpecOther);
}
inline bool isDoubleRealSpeculation(SpeculatedType value)
{
return value == SpecDoubleReal;
}
inline bool isDoubleSpeculation(SpeculatedType value)
{
return !!value && (value & SpecDouble) == value;
}
inline bool isDoubleSpeculationForArithmetic(SpeculatedType value)
{
return !!(value & SpecDouble);
}
inline bool isRealNumberSpeculation(SpeculatedType value)
{
return !!(value & SpecRealNumber) && !(value & ~SpecRealNumber);
}
inline bool isNumberSpeculation(SpeculatedType value)
{
return !!(value & SpecNumber) && !(value & ~SpecNumber);
}
inline bool isNumberSpeculationExpectingDefined(SpeculatedType value)
{
return isNumberSpeculation(value & ~SpecOther);
}
inline bool isBooleanSpeculation(SpeculatedType value)
{
return value == SpecBoolean;
}
inline bool isOtherSpeculation(SpeculatedType value)
{
return value == SpecOther;
}
inline bool isOtherOrEmptySpeculation(SpeculatedType value)
{
return !value || value == SpecOther;
}
inline bool isEmptySpeculation(SpeculatedType value)
{
return value == SpecEmpty;
}
void dumpSpeculation(PrintStream&, SpeculatedType);
void dumpSpeculationAbbreviated(PrintStream&, SpeculatedType);
MAKE_PRINT_ADAPTOR(SpeculationDump, SpeculatedType, dumpSpeculation);
MAKE_PRINT_ADAPTOR(AbbreviatedSpeculationDump, SpeculatedType, dumpSpeculationAbbreviated);
// Merge two predictions. Note that currently this just does left | right. It may
// seem tempting to do so directly, but you would be doing so at your own peril,
// since the merging protocol SpeculatedType may change at any time (and has already
// changed several times in its history).
inline SpeculatedType mergeSpeculations(SpeculatedType left, SpeculatedType right)
{
return left | right;
}
template<typename T>
inline bool mergeSpeculation(T& left, SpeculatedType right)
{
SpeculatedType newSpeculation = static_cast<T>(mergeSpeculations(static_cast<SpeculatedType>(left), right));
bool result = newSpeculation != static_cast<SpeculatedType>(left);
left = newSpeculation;
return result;
}
inline bool speculationChecked(SpeculatedType actual, SpeculatedType desired)
{
return (actual | desired) == desired;
}
SpeculatedType speculationFromClassInfo(const ClassInfo*);
SpeculatedType speculationFromStructure(Structure*);
SpeculatedType speculationFromCell(JSCell*);
SpeculatedType speculationFromValue(JSValue);
} // namespace JSC
#endif // SpeculatedType_h