blob: 0ff39d9b8769c3af9794ca7429ea8fece959f9e9 [file] [log] [blame]
/*
* Copyright (C) 2015-2018 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 "FPRInfo.h"
#include "GPRInfo.h"
#include "JSCJSValue.h"
#include "Reg.h"
#include "RegisterSet.h"
#include "ValueRecovery.h"
#include <wtf/PrintStream.h>
namespace JSC {
class AssemblyHelpers;
namespace B3 {
// We use this class to describe value representations at stackmaps. It's used both to force a
// representation and to get the representation. When the B3 client forces a representation, we say
// that it's an input. When B3 tells the client what representation it picked, we say that it's an
// output.
class ValueRep {
public:
enum Kind {
// As an input representation, this means that B3 can pick any representation. As an output
// representation, this means that we don't know. This will only arise as an output
// representation for the active arguments of Check/CheckAdd/CheckSub/CheckMul.
WarmAny,
// Same as WarmAny, but implies that the use is cold. A cold use is not counted as a use for
// computing the priority of the used temporary.
ColdAny,
// Same as ColdAny, but also implies that the use occurs after all other effects of the stackmap
// value.
LateColdAny,
// As an input representation, this means that B3 should pick some register. It could be a
// register that this claims to clobber!
SomeRegister,
// As an input representation, this means that B3 should pick some register but that this
// register is then cobbered with garbage. This only works for patchpoints.
SomeRegisterWithClobber,
// As an input representation, this tells us that B3 should pick some register, but implies
// that the def happens before any of the effects of the stackmap. This is only valid for
// the result constraint of a Patchpoint.
SomeEarlyRegister,
// As an input representation, this tells us that B3 should pick some register, but implies
// the use happens after any defs. This is only works for patchpoints.
SomeLateRegister,
// As an input representation, this forces a particular register. As an output
// representation, this tells us what register B3 picked.
Register,
// As an input representation, this forces a particular register and states that
// the register is used late. This means that the register is used after the result
// is defined (i.e, the result will interfere with this as an input).
// It's not a valid output representation.
LateRegister,
// As an output representation, this tells us what stack slot B3 picked. It's not a valid
// input representation.
Stack,
// As an input representation, this forces the value to end up in the argument area at some
// offset.
StackArgument,
// As an output representation, this tells us that B3 constant-folded the value.
Constant
};
ValueRep()
: m_kind(WarmAny)
{
}
explicit ValueRep(Reg reg)
: m_kind(Register)
{
u.reg = reg;
}
ValueRep(Kind kind)
: m_kind(kind)
{
ASSERT(kind == WarmAny || kind == ColdAny || kind == LateColdAny || kind == SomeRegister || kind == SomeRegisterWithClobber || kind == SomeEarlyRegister || kind == SomeLateRegister);
}
static ValueRep reg(Reg reg)
{
return ValueRep(reg);
}
static ValueRep lateReg(Reg reg)
{
ValueRep result(reg);
result.m_kind = LateRegister;
return result;
}
static ValueRep stack(intptr_t offsetFromFP)
{
ValueRep result;
result.m_kind = Stack;
result.u.offsetFromFP = offsetFromFP;
return result;
}
static ValueRep stackArgument(intptr_t offsetFromSP)
{
ValueRep result;
result.m_kind = StackArgument;
result.u.offsetFromSP = offsetFromSP;
return result;
}
static ValueRep constant(int64_t value)
{
ValueRep result;
result.m_kind = Constant;
result.u.value = value;
return result;
}
static ValueRep constantDouble(double value)
{
return ValueRep::constant(bitwise_cast<int64_t>(value));
}
Kind kind() const { return m_kind; }
bool operator==(const ValueRep& other) const
{
if (kind() != other.kind())
return false;
switch (kind()) {
case LateRegister:
case Register:
return u.reg == other.u.reg;
case Stack:
return u.offsetFromFP == other.u.offsetFromFP;
case StackArgument:
return u.offsetFromSP == other.u.offsetFromSP;
case Constant:
return u.value == other.u.value;
default:
return true;
}
}
bool operator!=(const ValueRep& other) const
{
return !(*this == other);
}
explicit operator bool() const { return kind() != WarmAny; }
bool isAny() const { return kind() == WarmAny || kind() == ColdAny || kind() == LateColdAny; }
bool isReg() const { return kind() == Register || kind() == LateRegister || kind() == SomeLateRegister; }
Reg reg() const
{
ASSERT(isReg());
return u.reg;
}
bool isGPR() const { return isReg() && reg().isGPR(); }
bool isFPR() const { return isReg() && reg().isFPR(); }
GPRReg gpr() const { return reg().gpr(); }
FPRReg fpr() const { return reg().fpr(); }
bool isStack() const { return kind() == Stack; }
intptr_t offsetFromFP() const
{
ASSERT(isStack());
return u.offsetFromFP;
}
bool isStackArgument() const { return kind() == StackArgument; }
intptr_t offsetFromSP() const
{
ASSERT(isStackArgument());
return u.offsetFromSP;
}
bool isConstant() const { return kind() == Constant; }
int64_t value() const
{
ASSERT(isConstant());
return u.value;
}
double doubleValue() const
{
return bitwise_cast<double>(value());
}
ValueRep withOffset(intptr_t offset) const
{
switch (kind()) {
case Stack:
return stack(offsetFromFP() + offset);
case StackArgument:
return stackArgument(offsetFromSP() + offset);
default:
return *this;
}
}
void addUsedRegistersTo(RegisterSet&) const;
RegisterSet usedRegisters() const;
// Get the used registers for a vector of ValueReps.
template<typename VectorType>
static RegisterSet usedRegisters(const VectorType& vector)
{
RegisterSet result;
for (const ValueRep& value : vector)
value.addUsedRegistersTo(result);
return result;
}
JS_EXPORT_PRIVATE void dump(PrintStream&) const;
// This has a simple contract: it emits code to restore the value into the given register. This
// will work even if it requires moving between bits a GPR and a FPR.
void emitRestore(AssemblyHelpers&, Reg) const;
// Computes the ValueRecovery assuming that the Value* was for a JSValue (i.e. Int64).
// NOTE: We should avoid putting JSValue-related methods in B3, but this was hard to avoid
// because some parts of JSC use ValueRecovery like a general "where my bits at" object, almost
// exactly like ValueRep.
ValueRecovery recoveryForJSValue() const;
private:
Kind m_kind;
union U {
Reg reg;
intptr_t offsetFromFP;
intptr_t offsetFromSP;
int64_t value;
U()
{
memset(static_cast<void*>(this), 0, sizeof(*this));
}
} u;
};
} } // namespace JSC::B3
namespace WTF {
void printInternal(PrintStream&, JSC::B3::ValueRep::Kind);
} // namespace WTF
#endif // ENABLE(B3_JIT)