mirror of
https://github.com/darlinghq/darling-JavaScriptCore.git
synced 2024-11-26 21:50:53 +00:00
868 lines
32 KiB
C++
868 lines
32 KiB
C++
/*
|
|
* Copyright (C) 2015-2017 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
|
|
|
|
#if ENABLE(B3_JIT)
|
|
|
|
#include "B3Bank.h"
|
|
#include "B3Effects.h"
|
|
#include "B3FrequentedBlock.h"
|
|
#include "B3Kind.h"
|
|
#include "B3Origin.h"
|
|
#include "B3SparseCollection.h"
|
|
#include "B3Type.h"
|
|
#include "B3ValueKey.h"
|
|
#include "B3Width.h"
|
|
#include <wtf/CommaPrinter.h>
|
|
#include <wtf/FastMalloc.h>
|
|
#include <wtf/IteratorRange.h>
|
|
#include <wtf/StdLibExtras.h>
|
|
#include <wtf/TriState.h>
|
|
|
|
namespace JSC { namespace B3 {
|
|
|
|
class BasicBlock;
|
|
class CheckValue;
|
|
class InsertionSet;
|
|
class PhiChildren;
|
|
class Procedure;
|
|
|
|
class JS_EXPORT_PRIVATE Value {
|
|
WTF_MAKE_FAST_ALLOCATED;
|
|
public:
|
|
static const char* const dumpPrefix;
|
|
|
|
static bool accepts(Kind) { return true; }
|
|
|
|
virtual ~Value();
|
|
|
|
unsigned index() const { return m_index; }
|
|
|
|
// Note that the kind is immutable, except for replacing values with:
|
|
// Identity, Nop, Oops, Jump, and Phi. See below for replaceWithXXX() methods.
|
|
Kind kind() const { return m_kind; }
|
|
|
|
Opcode opcode() const { return kind().opcode(); }
|
|
|
|
// Note that the kind is meant to be immutable. Do this when you know that this is safe. It's not
|
|
// usually safe.
|
|
void setKindUnsafely(Kind kind) { m_kind = kind; }
|
|
void setOpcodeUnsafely(Opcode opcode) { m_kind.setOpcode(opcode); }
|
|
|
|
// It's good practice to mirror Kind methods here, so you can say value->isBlah()
|
|
// instead of value->kind().isBlah().
|
|
bool isChill() const { return kind().isChill(); }
|
|
bool traps() const { return kind().traps(); }
|
|
|
|
Origin origin() const { return m_origin; }
|
|
void setOrigin(Origin origin) { m_origin = origin; }
|
|
|
|
Type type() const { return m_type; }
|
|
void setType(Type type) { m_type = type; }
|
|
|
|
// This is useful when lowering. Note that this is only valid for non-void values.
|
|
Bank resultBank() const { return bankForType(type()); }
|
|
Width resultWidth() const { return widthForType(type()); }
|
|
|
|
unsigned numChildren() const
|
|
{
|
|
if (m_numChildren == VarArgs)
|
|
return childrenVector().size();
|
|
return m_numChildren;
|
|
}
|
|
|
|
Value*& child(unsigned index)
|
|
{
|
|
ASSERT(index < numChildren());
|
|
return m_numChildren == VarArgs ? childrenVector()[index] : childrenArray()[index];
|
|
}
|
|
Value* child(unsigned index) const
|
|
{
|
|
ASSERT(index < numChildren());
|
|
return m_numChildren == VarArgs ? childrenVector()[index] : childrenArray()[index];
|
|
}
|
|
|
|
Value*& lastChild()
|
|
{
|
|
if (m_numChildren == VarArgs)
|
|
return childrenVector().last();
|
|
ASSERT(m_numChildren >= 1);
|
|
return childrenArray()[m_numChildren - 1];
|
|
}
|
|
Value* lastChild() const
|
|
{
|
|
if (m_numChildren == VarArgs)
|
|
return childrenVector().last();
|
|
ASSERT(m_numChildren >= 1);
|
|
return childrenArray()[m_numChildren - 1];
|
|
}
|
|
|
|
WTF::IteratorRange<Value**> children()
|
|
{
|
|
if (m_numChildren == VarArgs) {
|
|
Vector<Value*, 3>& vec = childrenVector();
|
|
return WTF::makeIteratorRange(&*vec.begin(), &*vec.end());
|
|
}
|
|
Value** buffer = childrenArray();
|
|
return {buffer, buffer + m_numChildren };
|
|
}
|
|
WTF::IteratorRange<Value* const*> children() const
|
|
{
|
|
if (m_numChildren == VarArgs) {
|
|
const Vector<Value*, 3>& vec = childrenVector();
|
|
return WTF::makeIteratorRange(&*vec.begin(), &*vec.end());
|
|
}
|
|
Value* const* buffer = childrenArray();
|
|
return {buffer, buffer + m_numChildren };
|
|
}
|
|
|
|
// If you want to replace all uses of this value with a different value, then replace this
|
|
// value with Identity. Then do a pass of performSubstitution() on all of the values that use
|
|
// this one. Usually we do all of this in one pass in pre-order, which ensures that the
|
|
// X->replaceWithIdentity() calls happen before the performSubstitution() calls on X's users.
|
|
void replaceWithIdentity(Value*);
|
|
|
|
// It's often necessary to kill a value. It's tempting to replace the value with Nop or to
|
|
// just remove it. But unless you are sure that the value is Void, you will probably still
|
|
// have other values that use this one. Sure, you may kill those later, or you might not. This
|
|
// method lets you kill a value safely. It will replace Void values with Nop and non-Void
|
|
// values with Identities on bottom constants. For this reason, this takes a callback that is
|
|
// responsible for creating bottoms. There's a utility for this, see B3BottomProvider.h. You
|
|
// can also access that utility using replaceWithBottom(InsertionSet&, size_t).
|
|
//
|
|
// You're guaranteed that bottom is zero.
|
|
template<typename BottomProvider>
|
|
void replaceWithBottom(const BottomProvider&);
|
|
|
|
void replaceWithBottom(InsertionSet&, size_t index);
|
|
|
|
// Use this if you want to kill a value and you are sure that the value is Void.
|
|
void replaceWithNop();
|
|
|
|
// Use this if you want to kill a value and you are sure that nobody is using it anymore.
|
|
void replaceWithNopIgnoringType();
|
|
|
|
void replaceWithPhi();
|
|
|
|
// These transformations are only valid for terminals.
|
|
void replaceWithJump(BasicBlock* owner, FrequentedBlock);
|
|
void replaceWithOops(BasicBlock* owner);
|
|
|
|
// You can use this form if owners are valid. They're usually not valid.
|
|
void replaceWithJump(FrequentedBlock);
|
|
void replaceWithOops();
|
|
|
|
void dump(PrintStream&) const;
|
|
void deepDump(const Procedure*, PrintStream&) const;
|
|
|
|
virtual void dumpSuccessors(const BasicBlock*, PrintStream&) const;
|
|
|
|
// This is how you cast Values. For example, if you want to do something provided that we have a
|
|
// ArgumentRegValue, you can do:
|
|
//
|
|
// if (ArgumentRegValue* argumentReg = value->as<ArgumentRegValue>()) {
|
|
// things
|
|
// }
|
|
//
|
|
// This will return null if this kind() != ArgumentReg. This works because this returns nullptr
|
|
// if T::accepts(kind()) returns false.
|
|
template<typename T>
|
|
T* as();
|
|
template<typename T>
|
|
const T* as() const;
|
|
|
|
// What follows are a bunch of helpers for inspecting and modifying values. Note that we have a
|
|
// bunch of different idioms for implementing such helpers. You can use virtual methods, and
|
|
// override from the various Value subclasses. You can put the method inside Value and make it
|
|
// non-virtual, and the implementation can switch on kind. The method could be inline or not.
|
|
// If a method is specific to some Value subclass, you could put it in the subclass, or you could
|
|
// put it on Value anyway. It's fine to pick whatever feels right, and we shouldn't restrict
|
|
// ourselves to any particular idiom.
|
|
|
|
bool isConstant() const;
|
|
bool isInteger() const;
|
|
|
|
virtual Value* negConstant(Procedure&) const;
|
|
virtual Value* addConstant(Procedure&, int32_t other) const;
|
|
virtual Value* addConstant(Procedure&, const Value* other) const;
|
|
virtual Value* subConstant(Procedure&, const Value* other) const;
|
|
virtual Value* mulConstant(Procedure&, const Value* other) const;
|
|
virtual Value* checkAddConstant(Procedure&, const Value* other) const;
|
|
virtual Value* checkSubConstant(Procedure&, const Value* other) const;
|
|
virtual Value* checkMulConstant(Procedure&, const Value* other) const;
|
|
virtual Value* checkNegConstant(Procedure&) const;
|
|
virtual Value* divConstant(Procedure&, const Value* other) const; // This chooses Div<Chill> semantics for integers.
|
|
virtual Value* uDivConstant(Procedure&, const Value* other) const;
|
|
virtual Value* modConstant(Procedure&, const Value* other) const; // This chooses Mod<Chill> semantics.
|
|
virtual Value* uModConstant(Procedure&, const Value* other) const;
|
|
virtual Value* bitAndConstant(Procedure&, const Value* other) const;
|
|
virtual Value* bitOrConstant(Procedure&, const Value* other) const;
|
|
virtual Value* bitXorConstant(Procedure&, const Value* other) const;
|
|
virtual Value* shlConstant(Procedure&, const Value* other) const;
|
|
virtual Value* sShrConstant(Procedure&, const Value* other) const;
|
|
virtual Value* zShrConstant(Procedure&, const Value* other) const;
|
|
virtual Value* rotRConstant(Procedure&, const Value* other) const;
|
|
virtual Value* rotLConstant(Procedure&, const Value* other) const;
|
|
virtual Value* bitwiseCastConstant(Procedure&) const;
|
|
virtual Value* iToDConstant(Procedure&) const;
|
|
virtual Value* iToFConstant(Procedure&) const;
|
|
virtual Value* doubleToFloatConstant(Procedure&) const;
|
|
virtual Value* floatToDoubleConstant(Procedure&) const;
|
|
virtual Value* absConstant(Procedure&) const;
|
|
virtual Value* ceilConstant(Procedure&) const;
|
|
virtual Value* floorConstant(Procedure&) const;
|
|
virtual Value* sqrtConstant(Procedure&) const;
|
|
|
|
virtual TriState equalConstant(const Value* other) const;
|
|
virtual TriState notEqualConstant(const Value* other) const;
|
|
virtual TriState lessThanConstant(const Value* other) const;
|
|
virtual TriState greaterThanConstant(const Value* other) const;
|
|
virtual TriState lessEqualConstant(const Value* other) const;
|
|
virtual TriState greaterEqualConstant(const Value* other) const;
|
|
virtual TriState aboveConstant(const Value* other) const;
|
|
virtual TriState belowConstant(const Value* other) const;
|
|
virtual TriState aboveEqualConstant(const Value* other) const;
|
|
virtual TriState belowEqualConstant(const Value* other) const;
|
|
virtual TriState equalOrUnorderedConstant(const Value* other) const;
|
|
|
|
// If the value is a comparison then this returns the inverted form of that comparison, if
|
|
// possible. It can be impossible for double comparisons, where for example LessThan and
|
|
// GreaterEqual behave differently. If this returns a value, it is a new value, which must be
|
|
// either inserted into some block or deleted.
|
|
Value* invertedCompare(Procedure&) const;
|
|
|
|
bool hasInt32() const;
|
|
int32_t asInt32() const;
|
|
bool isInt32(int32_t) const;
|
|
|
|
bool hasInt64() const;
|
|
int64_t asInt64() const;
|
|
bool isInt64(int64_t) const;
|
|
|
|
bool hasInt() const;
|
|
int64_t asInt() const;
|
|
bool isInt(int64_t value) const;
|
|
|
|
bool hasIntPtr() const;
|
|
intptr_t asIntPtr() const;
|
|
bool isIntPtr(intptr_t) const;
|
|
|
|
bool hasDouble() const;
|
|
double asDouble() const;
|
|
bool isEqualToDouble(double) const; // We say "isEqualToDouble" because "isDouble" would be a bit equality.
|
|
|
|
bool hasFloat() const;
|
|
float asFloat() const;
|
|
|
|
bool hasNumber() const;
|
|
template<typename T> bool isRepresentableAs() const;
|
|
template<typename T> T asNumber() const;
|
|
|
|
// Booleans in B3 are Const32(0) or Const32(1). So this is true if the type is Int32 and the only
|
|
// possible return values are 0 or 1. It's OK for this method to conservatively return false.
|
|
bool returnsBool() const;
|
|
|
|
bool isNegativeZero() const;
|
|
|
|
bool isRounded() const;
|
|
|
|
TriState asTriState() const;
|
|
bool isLikeZero() const { return asTriState() == TriState::False; }
|
|
bool isLikeNonZero() const { return asTriState() == TriState::True; }
|
|
|
|
Effects effects() const;
|
|
|
|
// This returns a ValueKey that describes that this Value returns when it executes. Returns an
|
|
// empty ValueKey if this Value is impure. Note that an operation that returns Void could still
|
|
// have a non-empty ValueKey. This happens for example with Check operations.
|
|
ValueKey key() const;
|
|
|
|
Value* foldIdentity() const;
|
|
|
|
// Makes sure that none of the children are Identity's. If a child points to Identity, this will
|
|
// repoint it at the Identity's child. For simplicity, this will follow arbitrarily long chains
|
|
// of Identity's.
|
|
bool performSubstitution();
|
|
|
|
// Free values are those whose presence is guaranteed not to hurt code. We consider constants,
|
|
// Identities, and Nops to be free. Constants are free because we hoist them to an optimal place.
|
|
// Identities and Nops are free because we remove them.
|
|
bool isFree() const;
|
|
|
|
// Walk the ancestors of this value (i.e. the graph of things it transitively uses). This
|
|
// either walks phis or not, depending on whether PhiChildren is null. Your callback gets
|
|
// called with the signature:
|
|
//
|
|
// (Value*) -> WalkStatus
|
|
enum WalkStatus {
|
|
Continue,
|
|
IgnoreChildren,
|
|
Stop
|
|
};
|
|
template<typename Functor>
|
|
void walk(const Functor& functor, PhiChildren* = nullptr);
|
|
|
|
// B3 purposefully only represents signed 32-bit offsets because that's what x86 can encode, and
|
|
// ARM64 cannot encode anything bigger. The IsLegalOffset type trait is then used on B3 Value
|
|
// methods to prevent implicit conversions by C++ from invalid offset types: these cause compilation
|
|
// to fail, instead of causing implementation-defined behavior (which often turns to exploit).
|
|
// OffsetType isn't sufficient to determine offset validity! Each Value opcode further has an
|
|
// isLegalOffset runtime method used to determine value legality at runtime. This is exposed to users
|
|
// of B3 to force them to reason about the target's offset.
|
|
typedef int32_t OffsetType;
|
|
template<typename Int>
|
|
struct IsLegalOffset {
|
|
static constexpr bool value = std::is_integral<Int>::value
|
|
&& std::is_signed<Int>::value
|
|
&& sizeof(Int) <= sizeof(OffsetType);
|
|
};
|
|
|
|
protected:
|
|
Value* cloneImpl() const;
|
|
|
|
void replaceWith(Kind, Type, BasicBlock*);
|
|
void replaceWith(Kind, Type, BasicBlock*, Value*);
|
|
|
|
virtual void dumpChildren(CommaPrinter&, PrintStream&) const;
|
|
virtual void dumpMeta(CommaPrinter&, PrintStream&) const;
|
|
|
|
// The specific value of VarArgs does not matter, but the value of the others is assumed to match their meaning.
|
|
enum NumChildren : uint8_t { Zero = 0, One = 1, Two = 2, Three = 3, VarArgs = 4};
|
|
|
|
char* childrenAlloc() { return bitwise_cast<char*>(this) + adjacencyListOffset(); }
|
|
const char* childrenAlloc() const { return bitwise_cast<const char*>(this) + adjacencyListOffset(); }
|
|
Vector<Value*, 3>& childrenVector()
|
|
{
|
|
ASSERT(m_numChildren == VarArgs);
|
|
return *bitwise_cast<Vector<Value*, 3>*>(childrenAlloc());
|
|
}
|
|
const Vector<Value*, 3>& childrenVector() const
|
|
{
|
|
ASSERT(m_numChildren == VarArgs);
|
|
return *bitwise_cast<Vector<Value*, 3> const*>(childrenAlloc());
|
|
}
|
|
Value** childrenArray()
|
|
{
|
|
ASSERT(m_numChildren != VarArgs);
|
|
return bitwise_cast<Value**>(childrenAlloc());
|
|
}
|
|
Value* const* childrenArray() const
|
|
{
|
|
ASSERT(m_numChildren != VarArgs);
|
|
return bitwise_cast<Value* const*>(childrenAlloc());
|
|
}
|
|
|
|
template<typename... Arguments>
|
|
static Opcode opcodeFromConstructor(Kind kind, Arguments...) { return kind.opcode(); }
|
|
ALWAYS_INLINE static size_t adjacencyListSpace(Kind kind)
|
|
{
|
|
switch (kind.opcode()) {
|
|
case FramePointer:
|
|
case Nop:
|
|
case Phi:
|
|
case Jump:
|
|
case Oops:
|
|
case EntrySwitch:
|
|
case ArgumentReg:
|
|
case Const32:
|
|
case Const64:
|
|
case ConstFloat:
|
|
case ConstDouble:
|
|
case BottomTuple:
|
|
case Fence:
|
|
case SlotBase:
|
|
case Get:
|
|
return 0;
|
|
case Return:
|
|
case Identity:
|
|
case Opaque:
|
|
case Neg:
|
|
case Clz:
|
|
case Abs:
|
|
case Ceil:
|
|
case Floor:
|
|
case Sqrt:
|
|
case SExt8:
|
|
case SExt16:
|
|
case Trunc:
|
|
case SExt32:
|
|
case ZExt32:
|
|
case FloatToDouble:
|
|
case IToD:
|
|
case DoubleToFloat:
|
|
case IToF:
|
|
case BitwiseCast:
|
|
case Branch:
|
|
case Depend:
|
|
case Load8Z:
|
|
case Load8S:
|
|
case Load16Z:
|
|
case Load16S:
|
|
case Load:
|
|
case Switch:
|
|
case Upsilon:
|
|
case Extract:
|
|
case Set:
|
|
case WasmAddress:
|
|
case WasmBoundsCheck:
|
|
return sizeof(Value*);
|
|
case Add:
|
|
case Sub:
|
|
case Mul:
|
|
case Div:
|
|
case UDiv:
|
|
case Mod:
|
|
case UMod:
|
|
case BitAnd:
|
|
case BitOr:
|
|
case BitXor:
|
|
case Shl:
|
|
case SShr:
|
|
case ZShr:
|
|
case RotR:
|
|
case RotL:
|
|
case Equal:
|
|
case NotEqual:
|
|
case LessThan:
|
|
case GreaterThan:
|
|
case LessEqual:
|
|
case GreaterEqual:
|
|
case Above:
|
|
case Below:
|
|
case AboveEqual:
|
|
case BelowEqual:
|
|
case EqualOrUnordered:
|
|
case AtomicXchgAdd:
|
|
case AtomicXchgAnd:
|
|
case AtomicXchgOr:
|
|
case AtomicXchgSub:
|
|
case AtomicXchgXor:
|
|
case AtomicXchg:
|
|
case Store8:
|
|
case Store16:
|
|
case Store:
|
|
return 2 * sizeof(Value*);
|
|
case Select:
|
|
case AtomicWeakCAS:
|
|
case AtomicStrongCAS:
|
|
return 3 * sizeof(Value*);
|
|
case CCall:
|
|
case Check:
|
|
case CheckAdd:
|
|
case CheckSub:
|
|
case CheckMul:
|
|
case Patchpoint:
|
|
return sizeof(Vector<Value*, 3>);
|
|
#ifdef NDEBUG
|
|
default:
|
|
break;
|
|
#endif
|
|
}
|
|
RELEASE_ASSERT_NOT_REACHED();
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
static char* allocateSpace(Opcode opcode, size_t size)
|
|
{
|
|
size_t adjacencyListSpace = Value::adjacencyListSpace(opcode);
|
|
// We must allocate enough space that replaceWithIdentity can work without buffer overflow.
|
|
size_t allocIdentitySize = sizeof(Value) + sizeof(Value*);
|
|
size_t allocSize = std::max(size + adjacencyListSpace, allocIdentitySize);
|
|
return static_cast<char*>(WTF::fastMalloc(allocSize));
|
|
}
|
|
|
|
protected:
|
|
template<typename ValueType, typename... Arguments>
|
|
static ValueType* allocate(Arguments... arguments)
|
|
{
|
|
char* alloc = allocateSpace(ValueType::opcodeFromConstructor(arguments...), sizeof(ValueType));
|
|
return new (alloc) ValueType(arguments...);
|
|
}
|
|
template<typename ValueType>
|
|
static ValueType* allocate(const ValueType& valueToClone)
|
|
{
|
|
char* alloc = allocateSpace(valueToClone.opcode(), sizeof(ValueType));
|
|
ValueType* result = new (alloc) ValueType(valueToClone);
|
|
result->buildAdjacencyList(sizeof(ValueType), valueToClone);
|
|
return result;
|
|
}
|
|
|
|
// Protected so it will only be called from allocate above, possibly through the subclasses'copy constructors
|
|
Value(const Value&) = default;
|
|
|
|
Value(Value&&) = delete;
|
|
Value& operator=(const Value&) = delete;
|
|
Value& operator=(Value&&) = delete;
|
|
|
|
size_t adjacencyListOffset() const;
|
|
|
|
friend class Procedure;
|
|
friend class SparseCollection<Value>;
|
|
|
|
private:
|
|
template<typename... Arguments>
|
|
void buildAdjacencyList(NumChildren numChildren, Arguments... arguments)
|
|
{
|
|
if (numChildren == VarArgs) {
|
|
new (childrenAlloc()) Vector<Value*, 3> { arguments... };
|
|
return;
|
|
}
|
|
ASSERT(numChildren == sizeof...(arguments));
|
|
new (childrenAlloc()) Value*[sizeof...(arguments)] { arguments... };
|
|
}
|
|
void buildAdjacencyList(size_t offset, const Value& valueToClone)
|
|
{
|
|
switch (valueToClone.m_numChildren) {
|
|
case VarArgs:
|
|
new (bitwise_cast<char*>(this) + offset) Vector<Value*, 3> (valueToClone.childrenVector());
|
|
break;
|
|
case Three:
|
|
bitwise_cast<Value**>(bitwise_cast<char*>(this) + offset)[2] = valueToClone.childrenArray()[2];
|
|
FALLTHROUGH;
|
|
case Two:
|
|
bitwise_cast<Value**>(bitwise_cast<char*>(this) + offset)[1] = valueToClone.childrenArray()[1];
|
|
FALLTHROUGH;
|
|
case One:
|
|
bitwise_cast<Value**>(bitwise_cast<char*>(this) + offset)[0] = valueToClone.childrenArray()[0];
|
|
break;
|
|
case Zero:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Checks that this kind is valid for use with B3::Value.
|
|
ALWAYS_INLINE static NumChildren numChildrenForKind(Kind kind, unsigned numArgs)
|
|
{
|
|
switch (kind.opcode()) {
|
|
case FramePointer:
|
|
case Nop:
|
|
case Phi:
|
|
case Jump:
|
|
case Oops:
|
|
case EntrySwitch:
|
|
if (UNLIKELY(numArgs))
|
|
badKind(kind, numArgs);
|
|
return Zero;
|
|
case Return:
|
|
if (UNLIKELY(numArgs > 1))
|
|
badKind(kind, numArgs);
|
|
return numArgs ? One : Zero;
|
|
case Identity:
|
|
case Opaque:
|
|
case Neg:
|
|
case Clz:
|
|
case Abs:
|
|
case Ceil:
|
|
case Floor:
|
|
case Sqrt:
|
|
case SExt8:
|
|
case SExt16:
|
|
case Trunc:
|
|
case SExt32:
|
|
case ZExt32:
|
|
case FloatToDouble:
|
|
case IToD:
|
|
case DoubleToFloat:
|
|
case IToF:
|
|
case BitwiseCast:
|
|
case Branch:
|
|
case Depend:
|
|
if (UNLIKELY(numArgs != 1))
|
|
badKind(kind, numArgs);
|
|
return One;
|
|
case Add:
|
|
case Sub:
|
|
case Mul:
|
|
case Div:
|
|
case UDiv:
|
|
case Mod:
|
|
case UMod:
|
|
case BitAnd:
|
|
case BitOr:
|
|
case BitXor:
|
|
case Shl:
|
|
case SShr:
|
|
case ZShr:
|
|
case RotR:
|
|
case RotL:
|
|
case Equal:
|
|
case NotEqual:
|
|
case LessThan:
|
|
case GreaterThan:
|
|
case LessEqual:
|
|
case GreaterEqual:
|
|
case Above:
|
|
case Below:
|
|
case AboveEqual:
|
|
case BelowEqual:
|
|
case EqualOrUnordered:
|
|
if (UNLIKELY(numArgs != 2))
|
|
badKind(kind, numArgs);
|
|
return Two;
|
|
case Select:
|
|
if (UNLIKELY(numArgs != 3))
|
|
badKind(kind, numArgs);
|
|
return Three;
|
|
default:
|
|
badKind(kind, numArgs);
|
|
break;
|
|
}
|
|
return VarArgs;
|
|
}
|
|
|
|
protected:
|
|
enum CheckedOpcodeTag { CheckedOpcode };
|
|
|
|
// Instantiate values via Procedure.
|
|
// This form requires specifying the type explicitly:
|
|
template<typename... Arguments>
|
|
explicit Value(CheckedOpcodeTag, Kind kind, Type type, NumChildren numChildren, Origin origin, Value* firstChild, Arguments... arguments)
|
|
: m_kind(kind)
|
|
, m_type(type)
|
|
, m_numChildren(numChildren)
|
|
, m_origin(origin)
|
|
{
|
|
buildAdjacencyList(numChildren, firstChild, arguments...);
|
|
}
|
|
// This form is for specifying the type explicitly when the opcode has no children:
|
|
explicit Value(CheckedOpcodeTag, Kind kind, Type type, NumChildren numChildren, Origin origin)
|
|
: m_kind(kind)
|
|
, m_type(type)
|
|
, m_numChildren(numChildren)
|
|
, m_origin(origin)
|
|
{
|
|
buildAdjacencyList(numChildren);
|
|
}
|
|
// This form is for those opcodes that can infer their type from the opcode alone, and that don't
|
|
// take any arguments:
|
|
explicit Value(CheckedOpcodeTag, Kind kind, NumChildren numChildren, Origin origin)
|
|
: m_kind(kind)
|
|
, m_type(typeFor(kind, nullptr))
|
|
, m_numChildren(numChildren)
|
|
, m_origin(origin)
|
|
{
|
|
buildAdjacencyList(numChildren);
|
|
}
|
|
// This form is for those opcodes that can infer their type from the opcode and first child:
|
|
explicit Value(CheckedOpcodeTag, Kind kind, NumChildren numChildren, Origin origin, Value* firstChild)
|
|
: m_kind(kind)
|
|
, m_type(typeFor(kind, firstChild))
|
|
, m_numChildren(numChildren)
|
|
, m_origin(origin)
|
|
{
|
|
buildAdjacencyList(numChildren, firstChild);
|
|
}
|
|
// This form is for those opcodes that can infer their type from the opcode and first and second child:
|
|
template<typename... Arguments>
|
|
explicit Value(CheckedOpcodeTag, Kind kind, NumChildren numChildren, Origin origin, Value* firstChild, Value* secondChild, Arguments... arguments)
|
|
: m_kind(kind)
|
|
, m_type(typeFor(kind, firstChild, secondChild))
|
|
, m_numChildren(numChildren)
|
|
, m_origin(origin)
|
|
{
|
|
buildAdjacencyList(numChildren, firstChild, secondChild, arguments...);
|
|
}
|
|
|
|
// This is the constructor you end up actually calling, if you're instantiating Value
|
|
// directly.
|
|
explicit Value(Kind kind, Type type, Origin origin)
|
|
: Value(CheckedOpcode, kind, type, Zero, origin)
|
|
{
|
|
RELEASE_ASSERT(numChildrenForKind(kind, 0) == Zero);
|
|
}
|
|
// We explicitly convert the extra arguments to Value* (they may be pointers to some subclasses of Value) to limit template explosion
|
|
template<typename... Arguments>
|
|
explicit Value(Kind kind, Origin origin, Arguments... arguments)
|
|
: Value(CheckedOpcode, kind, numChildrenForKind(kind, sizeof...(arguments)), origin, static_cast<Value*>(arguments)...)
|
|
{
|
|
}
|
|
template<typename... Arguments>
|
|
explicit Value(Kind kind, Type type, Origin origin, Value* firstChild, Arguments... arguments)
|
|
: Value(CheckedOpcode, kind, type, numChildrenForKind(kind, 1 + sizeof...(arguments)), origin, firstChild, static_cast<Value*>(arguments)...)
|
|
{
|
|
}
|
|
|
|
private:
|
|
friend class CheckValue; // CheckValue::convertToAdd() modifies m_kind.
|
|
|
|
static Type typeFor(Kind, Value* firstChild, Value* secondChild = nullptr);
|
|
|
|
// m_index to m_numChildren are arranged to fit in 64 bits.
|
|
protected:
|
|
unsigned m_index { UINT_MAX };
|
|
private:
|
|
Kind m_kind;
|
|
Type m_type;
|
|
protected:
|
|
NumChildren m_numChildren;
|
|
private:
|
|
Origin m_origin;
|
|
|
|
NO_RETURN_DUE_TO_CRASH static void badKind(Kind, unsigned);
|
|
|
|
public:
|
|
BasicBlock* owner { nullptr }; // computed by Procedure::resetValueOwners().
|
|
};
|
|
|
|
class DeepValueDump {
|
|
public:
|
|
DeepValueDump(const Procedure* proc, const Value* value)
|
|
: m_proc(proc)
|
|
, m_value(value)
|
|
{
|
|
}
|
|
|
|
void dump(PrintStream& out) const;
|
|
|
|
private:
|
|
const Procedure* m_proc;
|
|
const Value* m_value;
|
|
};
|
|
|
|
inline DeepValueDump deepDump(const Procedure& proc, const Value* value)
|
|
{
|
|
return DeepValueDump(&proc, value);
|
|
}
|
|
inline DeepValueDump deepDump(const Value* value)
|
|
{
|
|
return DeepValueDump(nullptr, value);
|
|
}
|
|
|
|
// The following macros are designed for subclasses of B3::Value to use.
|
|
// They are never required for correctness, but can improve the performance of child/lastChild/numChildren/children methods,
|
|
// for users that already know the specific subclass of Value they are manipulating.
|
|
// The first set is to be used when you know something about the number of children of all values of a class, including its subclasses:
|
|
// - B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN: always 0 children (e.g. Const32Value)
|
|
// - B3_SPECIALIZE_VALUE_FOR_FIXED_CHILDREN(n): always n children, with n in {1, 2, 3} (e.g. UpsilonValue, with n = 1)
|
|
// - B3_SPECIALIZE_VALUE_FOR_NON_VARARGS_CHILDREN: different numbers of children, but never a variable number at runtime (e.g. MemoryValue, that can have between 1 and 3 children)
|
|
// - B3_SPECIALIZE_VALUE_FOR_VARARGS_CHILDREN: always a varargs (e.g. CCallValue)
|
|
// The second set is only to be used by classes that we know are not further subclassed by anyone adding fields,
|
|
// as they hardcode the offset of the children array/vector (which is equal to the size of the object).
|
|
// - B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
|
|
// - B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_VARARGS_CHILDREN
|
|
#define B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN \
|
|
unsigned numChildren() const { return 0; } \
|
|
WTF::IteratorRange<Value**> children() { return {nullptr, nullptr}; } \
|
|
WTF::IteratorRange<Value* const*> children() const { return { nullptr, nullptr}; }
|
|
|
|
#define B3_SPECIALIZE_VALUE_FOR_FIXED_CHILDREN(n) \
|
|
public: \
|
|
unsigned numChildren() const { return n; } \
|
|
Value*& child(unsigned index) \
|
|
{ \
|
|
ASSERT(index <= n); \
|
|
return childrenArray()[index]; \
|
|
} \
|
|
Value* child(unsigned index) const \
|
|
{ \
|
|
ASSERT(index <= n); \
|
|
return childrenArray()[index]; \
|
|
} \
|
|
Value*& lastChild() \
|
|
{ \
|
|
return childrenArray()[n - 1]; \
|
|
} \
|
|
Value* lastChild() const \
|
|
{ \
|
|
return childrenArray()[n - 1]; \
|
|
} \
|
|
WTF::IteratorRange<Value**> children() \
|
|
{ \
|
|
Value** buffer = childrenArray(); \
|
|
return {buffer, buffer + n }; \
|
|
} \
|
|
WTF::IteratorRange<Value* const*> children() const \
|
|
{ \
|
|
Value* const* buffer = childrenArray(); \
|
|
return {buffer, buffer + n }; \
|
|
} \
|
|
|
|
#define B3_SPECIALIZE_VALUE_FOR_NON_VARARGS_CHILDREN \
|
|
public: \
|
|
unsigned numChildren() const { return m_numChildren; } \
|
|
Value*& child(unsigned index) { return childrenArray()[index]; } \
|
|
Value* child(unsigned index) const { return childrenArray()[index]; } \
|
|
Value*& lastChild() { return childrenArray()[numChildren() - 1]; } \
|
|
Value* lastChild() const { return childrenArray()[numChildren() - 1]; } \
|
|
WTF::IteratorRange<Value**> children() \
|
|
{ \
|
|
Value** buffer = childrenArray(); \
|
|
return {buffer, buffer + numChildren() }; \
|
|
} \
|
|
WTF::IteratorRange<Value* const*> children() const \
|
|
{ \
|
|
Value* const* buffer = childrenArray(); \
|
|
return {buffer, buffer + numChildren() }; \
|
|
} \
|
|
|
|
#define B3_SPECIALIZE_VALUE_FOR_VARARGS_CHILDREN \
|
|
public: \
|
|
unsigned numChildren() const { return childrenVector().size(); } \
|
|
Value*& child(unsigned index) { return childrenVector()[index]; } \
|
|
Value* child(unsigned index) const { return childrenVector()[index]; } \
|
|
Value*& lastChild() { return childrenVector().last(); } \
|
|
Value* lastChild() const { return childrenVector().last(); } \
|
|
WTF::IteratorRange<Value**> children() \
|
|
{ \
|
|
Vector<Value*, 3>& vec = childrenVector(); \
|
|
return WTF::makeIteratorRange(&*vec.begin(), &*vec.end()); \
|
|
} \
|
|
WTF::IteratorRange<Value* const*> children() const \
|
|
{ \
|
|
const Vector<Value*, 3>& vec = childrenVector(); \
|
|
return WTF::makeIteratorRange(&*vec.begin(), &*vec.end()); \
|
|
} \
|
|
|
|
// Only use this for classes with no subclass that add new fields (as it uses sizeof(*this))
|
|
// Also there is no point in applying this to classes with no children, as they don't have a children array to access.
|
|
#define B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN \
|
|
private: \
|
|
Value** childrenArray() \
|
|
{ \
|
|
return bitwise_cast<Value**>(bitwise_cast<char*>(this) + sizeof(*this)); \
|
|
} \
|
|
Value* const* childrenArray() const \
|
|
{ \
|
|
return bitwise_cast<Value* const*>(bitwise_cast<char const*>(this) + sizeof(*this)); \
|
|
}
|
|
|
|
// Only use this for classes with no subclass that add new fields (as it uses sizeof(*this))
|
|
#define B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_VARARGS_CHILDREN \
|
|
private: \
|
|
Vector<Value*, 3>& childrenVector() \
|
|
{ \
|
|
return *bitwise_cast<Vector<Value*, 3>*>(bitwise_cast<char*>(this) + sizeof(*this)); \
|
|
} \
|
|
const Vector<Value*, 3>& childrenVector() const \
|
|
{ \
|
|
return *bitwise_cast<Vector<Value*, 3> const*>(bitwise_cast<char const*>(this) + sizeof(*this)); \
|
|
} \
|
|
|
|
} } // namespace JSC::B3
|
|
|
|
#endif // ENABLE(B3_JIT)
|