wellton/hhvm
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade
Arquivos
244d4da93af58d7bb26703b3de5ca6321b997acb
hhvm/hphp/runtime/vm/jit/vector-translator.cpp
T
Guilherme Ottoni 244d4da93a Replace _ with - in file names under runtime/vm/jit/ 
Makes things more consistent, at least within this directory.
2013-07-11 15:11:11 -07:00

2607 linhas
87 KiB
C++
Original Anotar Histórico

/*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
*/
#include "hphp/runtime/base/strings.h"
#include "hphp/runtime/vm/member_operations.h"
#include "hphp/runtime/vm/jit/hhbc-translator.h"
#include "hphp/runtime/vm/jit/ir.h"
#include "hphp/runtime/vm/jit/ir-instruction.h"
#include "hphp/runtime/vm/jit/translator-x64.h"
// These files do ugly things with macros so include them last
#include "hphp/util/assert_throw.h"
#include "hphp/runtime/vm/jit/vector-translator-internal.h"
namespace HPHP { namespace JIT {
TRACE_SET_MOD(hhir);
using HPHP::Transl::Location;
static bool wantPropSpecializedWarnings() {
return !RuntimeOption::RepoAuthoritative ||
!RuntimeOption::EvalDisableSomeRepoAuthNotices;
}
bool VectorEffects::supported(Opcode op) {
return opcodeHasFlags(op, VectorProp | VectorElem);
}
bool VectorEffects::supported(const IRInstruction* inst) {
return supported(inst->op());
}
void VectorEffects::get(const IRInstruction* inst,
StoreLocFunc storeLocalValue,
SetLocTypeFunc setLocalType) {
// If the base for this instruction is a local address, the
// helper call might have side effects on the local's value
SSATmp* base = inst->src(vectorBaseIdx(inst));
IRInstruction* locInstr = base->inst();
if (locInstr->op() == LdLocAddr) {
UNUSED Type baseType = locInstr->dst()->type();
assert(baseType.equals(base->type()));
assert(baseType.isPtr() || baseType.isKnownDataType());
int loc = locInstr->extra<LdLocAddr>()->locId;
VectorEffects ve(inst);
if (ve.baseTypeChanged || ve.baseValChanged) {
storeLocalValue(loc, nullptr);
setLocalType(loc, ve.baseType.derefIfPtr());
}
}
}
namespace {
// Reduce baseType to a canonical unboxed, non-pointer form, returning (in
// basePtr and baseBoxed) whether the original type was a pointer or boxed,
// respectively. Whether or not the type is a pointer and/or boxed must be
// statically known, unless it's exactly equal to Gen.
void stripBase(Type& baseType, bool& basePtr, bool& baseBoxed) {
assert_not_implemented(baseType.isPtr() || baseType.notPtr());
basePtr = baseType.isPtr();
baseType = basePtr ? baseType.deref() : baseType;
assert_not_implemented(
baseType.equals(Type::Gen) || baseType.isBoxed() || baseType.notBoxed());
baseBoxed = baseType.isBoxed();
baseType = baseBoxed ? baseType.innerType() : baseType;
}
Opcode canonicalOp(Opcode op) {
if (op == ElemUX || op == ElemUXStk ||
op == UnsetElem || op == UnsetElemStk) {
return UnsetElem;
}
if (op == SetWithRefElem ||
op == SetWithRefElemStk ||
op == SetWithRefNewElem ||
op == SetWithRefNewElemStk) {
return SetWithRefElem;
}
return opcodeHasFlags(op, VectorProp) ? SetProp
: opcodeHasFlags(op, VectorElem) || op == ArraySet ? SetElem
: bad_value<Opcode>();
}
}
VectorEffects::VectorEffects(const IRInstruction* inst) {
int keyIdx = vectorKeyIdx(inst);
int valIdx = vectorValIdx(inst);
init(inst->op(),
inst->src(vectorBaseIdx(inst))->type(),
keyIdx == -1 ? Type::None : inst->src(keyIdx)->type(),
valIdx == -1 ? Type::None : inst->src(valIdx)->type());
}
VectorEffects::VectorEffects(Opcode op, Type base, Type key, Type val) {
init(op, base, key, val);
}
VectorEffects::VectorEffects(Opcode op,
SSATmp* base, SSATmp* key, SSATmp* val) {
auto typeOrNone =
[](SSATmp* val){ return val ? val->type() : Type::None; };
init(op, typeOrNone(base), typeOrNone(key), typeOrNone(val));
}
VectorEffects::VectorEffects(Opcode opc, const std::vector<SSATmp*>& srcs) {
int keyIdx = vectorKeyIdx(opc);
int valIdx = vectorValIdx(opc);
init(opc,
srcs[vectorBaseIdx(opc)]->type(),
keyIdx == -1 ? Type::None : srcs[keyIdx]->type(),
valIdx == -1 ? Type::None : srcs[valIdx]->type());
}
void VectorEffects::init(const Opcode rawOp, const Type origBase,
const Type key, const Type origVal) {
baseType = origBase;
bool basePtr, baseBoxed;
stripBase(baseType, basePtr, baseBoxed);
// Only certain types of bases are supported now but this list may expand in
// the future.
assert_not_implemented(basePtr ||
baseType.subtypeOfAny(Type::Obj, Type::Arr));
baseTypeChanged = baseValChanged = false;
// Canonicalize the op to SetProp/SetElem/UnsetElem/SetWithRefElem
auto const op = canonicalOp(rawOp);
/* Although it should work fine in practice, if we have a key it should
* either be a known DataType or Cell for now. */
assert(key.equals(Type::None) || key.isKnownDataType() ||
key.equals(Type::Cell));
// Deal with possible promotion to stdClass or array
if ((op == SetElem || op == SetProp || op == SetWithRefElem) &&
baseType.maybe(Type::Null | Type::Bool | Type::Str)) {
auto newBase = op == SetProp ? Type::Obj : Type::Arr;
if (baseBoxed) {
/* We always guard when loading from a Boxed type, so we don't *have* to
* fix the type when the base is boxed. But it's still a good idea to do
* something with it, since the inner type is used as a hint by
* LdRef. And since the next load of the base will be guarded anyway we
* can be optimistic and assume no promotion for string bases and
* promotion in other cases. */
baseType = baseType.isString() ? Type::Str : newBase;
} else if (baseType.isString() &&
(rawOp == SetElem || rawOp == SetElemStk)) {
/* If the base is known to be a string and the operation is exactly
* SetElem, we're guaranteed that either the base will end as a
* CountedStr or the instruction will throw an exception and side
* exit. */
baseType = Type::CountedStr;
} else {
/* Regardless of whether or not promotion happens, we know the base
* cannot be Null after the operation. If the base was a subtype of Null
* this will give newBase. */
baseType = (baseType - Type::Null) | newBase;
}
baseValChanged = true;
}
if ((op == SetElem || op == UnsetElem || op == SetWithRefElem) &&
baseType.maybe(Type::Arr | Type::Str)) {
/* Modifying an array or string element, even when COW doesn't kick in,
* produces a new SSATmp for the base. StaticArr/StaticStr may be promoted
* to CountedArr/CountedStr. */
baseValChanged = true;
if (baseType.maybe(Type::StaticArr)) baseType |= Type::CountedArr;
if (baseType.maybe(Type::StaticStr)) baseType |= Type::CountedStr;
}
// The final baseType should be a pointer/box iff the input was
baseType = baseBoxed ? baseType.box() : baseType;
baseType = basePtr ? baseType.ptr() : baseType;
baseTypeChanged = baseTypeChanged || baseType != origBase;
/* Boxed bases may have their inner value changed but the value of the box
* will never change. */
baseValChanged = !baseBoxed && (baseValChanged || baseTypeChanged);
}
// vectorBaseIdx returns the src index for inst's base operand.
int vectorBaseIdx(Opcode opc) {
return opc == SetNewElem || opc == SetNewElemStk ? 0
: opc == BindNewElem || opc == BindNewElemStk ? 0
: opc == ArraySet ? 1
: opc == SetOpProp || opc == SetOpPropStk ? 1
: opcodeHasFlags(opc, VectorProp) ? 2
: opcodeHasFlags(opc, VectorElem) ? 1
: bad_value<int>();
}
int vectorBaseIdx(const IRInstruction* inst) {
return vectorBaseIdx(inst->op());
}
// vectorKeyIdx returns the src index for inst's key operand.
int vectorKeyIdx(Opcode opc) {
return opc == SetNewElem || opc == SetNewElemStk ? -1
: opc == SetWithRefNewElem || opc == SetWithRefNewElemStk ? -1
: opc == BindNewElem || opc == BindNewElem ? -1
: opc == ArraySet ? 2
: opc == SetOpProp || opc == SetOpPropStk ? 2
: opcodeHasFlags(opc, VectorProp) ? 3
: opcodeHasFlags(opc, VectorElem) ? 2
: bad_value<int>();
}
int vectorKeyIdx(const IRInstruction* inst) {
return vectorKeyIdx(inst->op());
}
// vectorValIdx returns the src index for inst's value operand.
int vectorValIdx(Opcode opc) {
switch (opc) {
case VGetProp: case VGetPropStk:
case IncDecProp: case IncDecPropStk:
case PropDX: case PropDXStk:
case VGetElem: case VGetElemStk:
case UnsetElem: case UnsetElemStk:
case IncDecElem: case IncDecElemStk:
case ElemDX: case ElemDXStk:
case ElemUX: case ElemUXStk:
return -1;
case ArraySet: return 3;
case SetNewElem: case SetNewElemStk: return 1;
case SetWithRefNewElem: case SetWithRefNewElemStk: return 2;
case BindNewElem: case BindNewElemStk: return 1;
case SetOpProp: case SetOpPropStk: return 3;
default:
return opcodeHasFlags(opc, VectorProp) ? 4
: opcodeHasFlags(opc, VectorElem) ? 3
: bad_value<int>();
}
}
int vectorValIdx(const IRInstruction* inst) {
return vectorValIdx(inst->op());
}
HhbcTranslator::VectorTranslator::VectorTranslator(
const NormalizedInstruction& ni,
HhbcTranslator& ht)
: m_ni(ni)
, m_ht(ht)
, m_tb(*m_ht.m_tb)
, m_irf(m_ht.m_irFactory)
, m_mii(getMInstrInfo(ni.mInstrOp()))
, m_marker(ht.makeMarker(ht.bcOff()))
, m_needMIS(true)
, m_misBase(nullptr)
, m_base(nullptr)
, m_result(nullptr)
, m_strTestResult(nullptr)
, m_failedSetTrace(nullptr)
{
}
template<typename... Srcs>
SSATmp* HhbcTranslator::VectorTranslator::genStk(Opcode opc, IRTrace* taken,
Srcs... srcs) {
assert(opcodeHasFlags(opc, HasStackVersion));
assert(!opcodeHasFlags(opc, ModifiesStack));
std::vector<SSATmp*> srcVec({srcs...});
SSATmp* base = srcVec[vectorBaseIdx(opc)];
/* If the base is a pointer to a stack cell and the operation might change
* its type and/or value, use the version of the opcode that returns a new
* StkPtr. */
if (base->inst()->op() == LdStackAddr) {
VectorEffects ve(opc, srcVec);
if (ve.baseTypeChanged || ve.baseValChanged) {
opc = getStackModifyingOpcode(opc);
}
}
return gen(opc, taken, srcs...);
}
void HhbcTranslator::VectorTranslator::emit() {
// Assign stack slots to our stack inputs
numberStackInputs();
// Emit the base and every intermediate op
emitMPre();
// Emit the final operation
emitFinalMOp();
// Cleanup: decref inputs and scratch values
emitMPost();
}
// Returns a pointer to the base of the current MInstrState struct, or
// a null pointer if it's not needed.
SSATmp* HhbcTranslator::VectorTranslator::genMisPtr() {
if (m_needMIS) {
return gen(LdAddr, m_misBase, cns(kReservedRSPSpillSpace));
} else {
return gen(DefConst, Type::PtrToCell, ConstData(nullptr));
}
}
// Inspect the instruction we're about to translate and determine if
// it can be executed without using an MInstrState struct.
void HhbcTranslator::VectorTranslator::checkMIState() {
auto const& baseRtt = m_ni.inputs[m_mii.valCount()]->rtt;
Type baseType = Type::fromRuntimeType(baseRtt);
const bool isCGetM = m_ni.mInstrOp() == OpCGetM;
const bool isSetM = m_ni.mInstrOp() == OpSetM;
const bool isIssetM = m_ni.mInstrOp() == OpIssetM;
const bool isUnsetM = m_ni.mInstrOp() == OpUnsetM;
const bool isSingle = m_ni.immVecM.size() == 1;
assert(baseType.isBoxed() || baseType.notBoxed());
baseType = baseType.unbox();
// CGetM or SetM with no unknown property offsets
const bool simpleProp = !mInstrHasUnknownOffsets(m_ni, contextClass()) &&
(isCGetM || isSetM);
// SetM with only one element
const bool singlePropSet = isSingle && isSetM &&
mcodeMaybePropName(m_ni.immVecM[0]);
// Array access with one element in the vector
const bool singleElem = isSingle && mcodeMaybeArrayOrMapKey(m_ni.immVecM[0]);
// SetM with one vector array element
const bool simpleArraySet = isSetM && singleElem;
// IssetM with one vector array element and an Arr base
const bool simpleArrayIsset = isIssetM && singleElem &&
baseType.subtypeOf(Type::Arr);
// IssetM with one vector array element and a collection type
const bool simpleCollectionIsset = isIssetM && singleElem &&
baseType.strictSubtypeOf(Type::Obj) &&
isOptimizableCollectionClass(baseType.getClass());
// UnsetM on an array with one vector element
const bool simpleArrayUnset = isUnsetM && singleElem;
// UnsetM on a non-standard base. Always a noop or fatal.
const bool badUnset = isUnsetM && baseType.not(Type::Arr | Type::Obj);
// CGetM on an array with a base that won't use MInstrState. Str
// will use tvScratch and Obj will fatal or use tvRef.
const bool simpleArrayGet = isCGetM && singleElem &&
baseType.not(Type::Str | Type::Obj);
const bool simpleCollectionGet = isCGetM && singleElem &&
baseType.strictSubtypeOf(Type::Obj) &&
isOptimizableCollectionClass(baseType.getClass());
if (simpleProp || singlePropSet ||
simpleArraySet || simpleArrayGet || simpleCollectionGet ||
simpleArrayUnset || badUnset || simpleCollectionIsset ||
simpleArrayIsset) {
setNoMIState();
}
}
void HhbcTranslator::VectorTranslator::emitMPre() {
checkMIState();
if (HPHP::Trace::moduleEnabled(HPHP::Trace::minstr, 1)) {
emitMTrace();
}
if (m_needMIS) {
m_misBase = gen(DefMIStateBase);
SSATmp* uninit = m_tb.genDefUninit();
if (nLogicalRatchets() > 0) {
gen(StMem, m_misBase, cns(HHIR_MISOFF(tvRef)), uninit);
gen(StMem, m_misBase, cns(HHIR_MISOFF(tvRef2)), uninit);
}
}
// The base location is input 0 or 1, and the location code is stored
// separately from m_ni.immVecM, so input indices (iInd) and member indices
// (mInd) commonly differ. Additionally, W members have no corresponding
// inputs, so it is necessary to track the two indices separately.
m_iInd = m_mii.valCount();
emitBaseOp();
++m_iInd;
// Iterate over all but the last member, which is consumed by a final
// operation.
for (m_mInd = 0; m_mInd < m_ni.immVecM.size() - 1; ++m_mInd) {
emitIntermediateOp();
emitRatchetRefs();
}
}
void HhbcTranslator::VectorTranslator::emitMTrace() {
auto rttStr = [this](int i) {
return Type::fromRuntimeType(m_ni.inputs[i]->rtt).unbox().toString();
};
std::ostringstream shape;
int iInd = m_mii.valCount();
const char* separator = "";
shape << opcodeToName(m_ni.mInstrOp()) << " <";
auto baseLoc = m_ni.immVec.locationCode();
shape << folly::format("{}:{} ", locationCodeString(baseLoc), rttStr(iInd));
++iInd;
for (int mInd = 0; mInd < m_ni.immVecM.size(); ++mInd) {
auto mcode = m_ni.immVecM[mInd];
shape << separator;
if (mcode == MW) {
shape << "MW";
} else if (mcodeMaybeArrayOrMapKey(mcode)) {
shape << "ME:" << rttStr(iInd);
} else if (mcodeMaybePropName(mcode)) {
shape << "MP:" << rttStr(iInd);
} else {
not_reached();
}
if (mcode != MW) ++iInd;
separator = " ";
}
shape << '>';
gen(IncStatGrouped,
cns(StringData::GetStaticString("vector instructions")),
cns(StringData::GetStaticString(shape.str())),
cns(1));
}
// Build a map from (stack) input index to stack index.
void HhbcTranslator::VectorTranslator::numberStackInputs() {
// Stack inputs are pushed in the order they appear in the vector
// from left to right, so earlier elements in the vector are at
// higher offsets in the stack. m_mii.valCount() tells us how many
// rvals the instruction takes on the stack; they're pushed after
// any vector elements and we want to ignore them here.
bool stackRhs = m_mii.valCount() &&
m_ni.inputs[0]->location.space == Location::Stack;
int stackIdx = (int)stackRhs + m_ni.immVec.numStackValues() - 1;
for (unsigned i = m_mii.valCount(); i < m_ni.inputs.size(); ++i) {
const Location& l = m_ni.inputs[i]->location;
switch (l.space) {
case Location::Stack:
assert(stackIdx >= 0);
m_stackInputs[i] = stackIdx--;
break;
default:
break;
}
}
assert(stackIdx == (stackRhs ? 0 : -1));
if (stackRhs) {
// If this instruction does have an RHS, it will be input 0 at
// stack offset 0.
assert(m_mii.valCount() == 1);
m_stackInputs[0] = 0;
}
}
SSATmp* HhbcTranslator::VectorTranslator::getBase() {
assert(m_iInd == m_mii.valCount());
return getInput(m_iInd);
}
SSATmp* HhbcTranslator::VectorTranslator::getKey() {
SSATmp* key = getInput(m_iInd);
auto keyType = key->type();
assert(keyType.isBoxed() || keyType.notBoxed());
if (keyType.isBoxed()) {
key = gen(LdRef, Type::Cell, key);
}
return key;
}
SSATmp* HhbcTranslator::VectorTranslator::getValue() {
// If an instruction takes an rhs, it's always input 0.
assert(m_mii.valCount() == 1);
const int kValIdx = 0;
return getInput(kValIdx);
}
SSATmp* HhbcTranslator::VectorTranslator::getValAddr() {
assert(m_mii.valCount() == 1);
const DynLocation& dl = *m_ni.inputs[0];
const Location& l = dl.location;
if (l.space == Location::Local) {
assert(!mapContains(m_stackInputs, 0));
return m_ht.ldLocAddr(l.offset);
} else {
assert(l.space == Location::Stack);
assert(mapContains(m_stackInputs, 0));
m_ht.spillStack();
return m_ht.ldStackAddr(m_stackInputs[0]);
}
}
SSATmp* HhbcTranslator::VectorTranslator::getInput(unsigned i) {
const DynLocation& dl = *m_ni.inputs[i];
const Location& l = dl.location;
assert(mapContains(m_stackInputs, i) == (l.space == Location::Stack));
switch (l.space) {
case Location::Stack: {
SSATmp* val = m_ht.top(Type::Gen | Type::Cls, m_stackInputs[i]);
// Check if the type on our eval stack is at least as specific as what
// Transl::Translator came up with. We allow boxed types with differing
// inner types because of the different ways the two systems deal with
// reference types.
auto t = Type::fromRuntimeType(dl.rtt);
if (!val->isA(t) && !(val->isBoxed() && t.isBoxed())) {
FTRACE(1, "{}: hhir stack has a {} where Translator had a {}\n",
__func__, val->type().toString(), t.toString());
// Normally here we would make sure that Translator gave us a sensical
// type, but since we could be getting inputs from type-predicted
// instructions, we can't actually be sure that the types are going to
// match up. refineType is just going to ignore the Translator type
// if the runtime type is completely unrelated.
m_ht.refineType(val, t);
}
return val;
}
case Location::Local:
return m_ht.ldLoc(l.offset);
case Location::Litstr:
return cns(m_ht.lookupStringId(l.offset));
case Location::Litint:
return cns(l.offset);
case Location::This:
return gen(LdThis, m_tb.fp());
default: not_reached();
}
}
void HhbcTranslator::VectorTranslator::emitBaseLCR() {
const MInstrAttr& mia = m_mii.getAttr(m_ni.immVec.locationCode());
const DynLocation& base = *m_ni.inputs[m_iInd];
auto baseType = Type::fromRuntimeType(base.rtt);
assert(baseType.isKnownDataType());
if (base.location.isLocal()) {
// Check for Uninit and warn/promote to InitNull as appropriate
if (baseType.subtypeOf(Type::Uninit)) {
if (mia & MIA_warn) {
gen(RaiseUninitLoc, getEmptyCatchTrace(),
LocalId(base.location.offset));
}
if (mia & MIA_define) {
gen(
StLoc,
LocalId(base.location.offset),
m_tb.fp(),
m_tb.genDefInitNull()
);
baseType = Type::InitNull;
}
}
}
// If the base is a box with a type that's changed, we need to bail out of
// the tracelet and retranslate. Doing an exit here is a little sketchy since
// we may have already emitted instructions with memory effects to initialize
// the MInstrState. These particular stores are harmless though, and the
// worst outcome here is that we'll end up doing the stores twice, once for
// this instruction and once at the beginning of the retranslation.
IRTrace* failedRef = baseType.isBoxed() ? m_ht.getExitTrace() : nullptr;
if ((baseType.subtypeOfAny(Type::Obj, Type::BoxedObj) &&
mcodeMaybePropName(m_ni.immVecM[0])) ||
isSimpleCollectionOp() != SimpleOp::None) {
// In these cases we can pass the base by value, after unboxing if needed.
m_base = gen(Unbox, failedRef, getBase());
assert(m_base->isA(baseType.unbox()));
} else {
// Everything else is passed by reference. We don't have to worry about
// unboxing here, since all the generic helpers understand boxed bases.
if (baseType.isBoxed()) {
SSATmp* box = getBase();
assert(box->isA(Type::BoxedCell));
// Guard that the inner type hasn't changed
gen(LdRef, baseType.innerType(), failedRef, box);
}
if (base.location.space == Location::Local) {
m_base = m_ht.ldLocAddr(base.location.offset);
} else {
assert(base.location.space == Location::Stack);
// Make sure the stack is clean before getting a pointer to one of its
// elements.
m_ht.spillStack();
assert(m_stackInputs.count(m_iInd));
m_base = m_ht.ldStackAddr(m_stackInputs[m_iInd]);
}
assert(m_base->type().isPtr());
}
}
// Is the current instruction a 1-element simple collection (includes Array),
// operation?
HhbcTranslator::VectorTranslator::SimpleOp
HhbcTranslator::VectorTranslator::isSimpleCollectionOp() {
SSATmp* base = getInput(m_mii.valCount());
auto baseType = base->type().unbox();
HPHP::Op op = m_ni.mInstrOp();
if ((op == OpSetM || op == OpCGetM || op == OpIssetM) &&
isSimpleBase() &&
isSingleMember()) {
if (baseType.subtypeOf(Type::Arr)) {
if (mcodeMaybeArrayOrMapKey(m_ni.immVecM[0])) {
SSATmp* key = getInput(m_mii.valCount() + 1);
if (key->isA(Type::Int) || key->isA(Type::Str)) {
return SimpleOp::Array;
}
}
} else if (baseType.strictSubtypeOf(Type::Obj)) {
const Class* klass = baseType.getClass();
if (klass == c_Vector::s_cls ||
klass == c_Pair::s_cls) {
if (mcodeMaybeVectorKey(m_ni.immVecM[0])) {
SSATmp* key = getInput(m_mii.valCount() + 1);
if (key->isA(Type::Int)) {
return (klass == c_Vector::s_cls) ?
SimpleOp::Vector : SimpleOp::Pair;
}
}
} else if (klass == c_Map::s_cls ||
klass == c_StableMap::s_cls) {
if (mcodeMaybeArrayOrMapKey(m_ni.immVecM[0])) {
SSATmp* key = getInput(m_mii.valCount() + 1);
if (key->isA(Type::Int) || key->isA(Type::Str)) {
return (klass == c_Map::s_cls) ?
SimpleOp::Map : SimpleOp::StableMap;
}
}
}
}
}
return SimpleOp::None;
}
// "Simple" bases are stack cells and locals.
bool HhbcTranslator::VectorTranslator::isSimpleBase() {
LocationCode loc = m_ni.immVec.locationCode();
return loc == LL || loc == LC || loc == LR;
}
bool HhbcTranslator::VectorTranslator::isSingleMember() {
return m_ni.immVecM.size() == 1;
}
void HhbcTranslator::VectorTranslator::emitBaseH() {
m_base = gen(LdThis, m_tb.fp());
}
void HhbcTranslator::VectorTranslator::emitBaseN() {
PUNT(emitBaseN);
}
template <bool warn, bool define>
static inline TypedValue* baseGImpl(TypedValue *key,
MInstrState* mis) {
TypedValue* base;
StringData* name = prepareKey(key);
VarEnv* varEnv = g_vmContext->m_globalVarEnv;
assert(varEnv != NULL);
base = varEnv->lookup(name);
if (base == NULL) {
if (warn) {
raise_notice(Strings::UNDEFINED_VARIABLE, name->data());
}
if (define) {
TypedValue tv;
tvWriteNull(&tv);
varEnv->set(name, &tv);
base = varEnv->lookup(name);
} else {
return const_cast<TypedValue*>(init_null_variant.asTypedValue());
}
}
decRefStr(name);
if (base->m_type == KindOfRef) {
base = base->m_data.pref->tv();
}
return base;
}
namespace VectorHelpers {
TypedValue* baseG(TypedValue key, MInstrState* mis) {
return baseGImpl<false, false>(&key, mis);
}
TypedValue* baseGW(TypedValue key, MInstrState* mis) {
return baseGImpl<true, false>(&key, mis);
}
TypedValue* baseGD(TypedValue key, MInstrState* mis) {
return baseGImpl<false, true>(&key, mis);
}
TypedValue* baseGWD(TypedValue key, MInstrState* mis) {
return baseGImpl<true, true>(&key, mis);
}
}
void HhbcTranslator::VectorTranslator::emitBaseG() {
const MInstrAttr& mia = m_mii.getAttr(m_ni.immVec.locationCode());
typedef TypedValue* (*OpFunc)(TypedValue, MInstrState*);
using namespace VectorHelpers;
static const OpFunc opFuncs[] = {baseG, baseGW, baseGD, baseGWD};
OpFunc opFunc = opFuncs[mia & MIA_base];
SSATmp* gblName = getBase();
m_base = gen(BaseG,
getEmptyCatchTrace(),
cns(reinterpret_cast<TCA>(opFunc)),
gblName,
genMisPtr());
}
void HhbcTranslator::VectorTranslator::emitBaseS() {
const int kClassIdx = m_ni.inputs.size() - 1;
SSATmp* key = getKey();
SSATmp* clsRef = getInput(kClassIdx);
m_base = gen(LdClsPropAddr,
clsRef,
key,
CTX());
}
void HhbcTranslator::VectorTranslator::emitBaseOp() {
LocationCode lCode = m_ni.immVec.locationCode();
switch (lCode) {
case LL: case LC: case LR: emitBaseLCR(); break;
case LH: emitBaseH(); break;
case LGL: case LGC: emitBaseG(); break;
case LNL: case LNC: emitBaseN(); break;
case LSL: case LSC: emitBaseS(); break;
default: not_reached();
}
}
void HhbcTranslator::VectorTranslator::emitIntermediateOp() {
switch (m_ni.immVecM[m_mInd]) {
case MEC: case MEL: case MET: case MEI: {
emitElem();
++m_iInd;
break;
}
case MPC: case MPL: case MPT:
emitProp();
++m_iInd;
break;
case MW:
assert(m_mii.newElem());
emitNewElem();
break;
default: not_reached();
}
}
void HhbcTranslator::VectorTranslator::emitProp() {
const Class* knownCls = nullptr;
const auto propInfo = getPropertyOffset(m_ni, contextClass(),
knownCls, m_mii,
m_mInd, m_iInd);
auto mia = m_mii.getAttr(m_ni.immVecM[m_mInd]);
if (propInfo.offset == -1 || (mia & Unset)) {
emitPropGeneric();
} else {
emitPropSpecialized(mia, propInfo);
}
}
template <MInstrAttr attrs, bool isObj>
static inline TypedValue* propImpl(Class* ctx, TypedValue* base,
TypedValue keyVal, MInstrState* mis) {
return Prop<WDU(attrs), isObj>(
mis->tvScratch, mis->tvRef, ctx, base, &keyVal);
}
#define HELPER_TABLE(m) \
/* name attrs isObj */ \
m(propC, None, false) \
m(propCD, Define, false) \
m(propCDO, Define, true) \
m(propCO, None, true) \
m(propCU, Unset, false) \
m(propCUO, Unset, true) \
m(propCW, Warn, false) \
m(propCWD, WarnDefine, false) \
m(propCWDO, WarnDefine, true) \
m(propCWO, Warn, true)
#define PROP(nm, ...) \
TypedValue* nm(Class* ctx, TypedValue* base, TypedValue key, \
MInstrState* mis) { \
return propImpl<__VA_ARGS__>(ctx, base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitPropGeneric() {
MemberCode mCode = m_ni.immVecM[m_mInd];
MInstrAttr mia = MInstrAttr(m_mii.getAttr(mCode) & MIA_intermediate_prop);
if ((mia & Unset) && m_base->type().strip().not(Type::Obj)) {
m_base = m_tb.genPtrToInitNull();
return;
}
typedef TypedValue* (*OpFunc)(Class*, TypedValue*, TypedValue, MInstrState*);
SSATmp* key = getKey();
BUILD_OPTAB(mia, m_base->isA(Type::Obj));
if (mia & Define) {
m_base = genStk(PropDX, getCatchTrace(), cns((TCA)opFunc), CTX(),
m_base, key, genMisPtr());
} else {
m_base = gen(PropX, getCatchTrace(),
cns((TCA)opFunc), CTX(), m_base, key, genMisPtr());
}
}
#undef HELPER_TABLE
/*
* Helper for emitPropSpecialized to check if a property is Uninit. It
* returns a pointer to the property's address, or init_null_variant
* if the property was Uninit and doDefine is false.
*
* We can omit the uninit check for properties that we know may not be
* uninit due to the frontend's type inference.
*/
SSATmp* HhbcTranslator::VectorTranslator::checkInitProp(
SSATmp* baseAsObj,
SSATmp* propAddr,
PropInfo propInfo,
bool doWarn,
bool doDefine) {
SSATmp* key = getKey();
assert(key->isA(Type::StaticStr));
assert(baseAsObj->isA(Type::Obj));
assert(propAddr->type().isPtr());
auto const needsCheck =
propInfo.hphpcType == KindOfInvalid &&
// The m_mInd check is to avoid initializing a property to
// InitNull right before it's going to be set to something else.
(doWarn || (doDefine && m_mInd < m_ni.immVecM.size() - 1));
if (!needsCheck) return propAddr;
return m_tb.cond(m_ht.curFunc(),
[&] (Block* taken) {
gen(CheckInitMem, taken, propAddr, cns(0));
},
[&] { // Next: Property isn't Uninit. Do nothing.
return propAddr;
},
[&] { // Taken: Property is Uninit. Raise a warning and return
// a pointer to InitNull, either in the object or
// init_null_variant.
m_tb.hint(Block::Hint::Unlikely);
if (doWarn && wantPropSpecializedWarnings()) {
gen(RaiseUndefProp, m_ht.getCatchTrace(), baseAsObj, key);
}
if (doDefine) {
gen(
StProp,
baseAsObj,
cns(propInfo.offset),
m_tb.genDefInitNull()
);
return propAddr;
}
return cns((const TypedValue*)&init_null_variant);
}
);
}
Class* HhbcTranslator::VectorTranslator::contextClass() const {
return m_ht.curFunc()->cls();
}
void HhbcTranslator::VectorTranslator::emitPropSpecialized(const MInstrAttr mia,
PropInfo propInfo) {
assert(!(mia & MIA_warn) || !(mia & MIA_unset));
const bool doWarn = mia & MIA_warn;
const bool doDefine = mia & MIA_define || mia & MIA_unset;
SSATmp* initNull = cns((const TypedValue*)&init_null_variant);
/*
* Type-inference from hphpc only tells us that this is either an object of a
* given class type or null. If it's not an object, it has to be a null type
* based on type inference. (It could be KindOfRef with an object inside,
* except that this isn't inferred for object properties so we're fine not
* checking KindOfRef in that case.)
*
* On the other hand, if m_base->isA(Type::Obj), we're operating on the base
* which was already guarded by tracelet guards (and may have been KindOfRef,
* but the Base* op already handled this). So we only need to do a type
* check against null here in the intermediate cases.
*/
if (m_base->isA(Type::Obj)) {
SSATmp* propAddr = gen(LdPropAddr, m_base, cns(propInfo.offset));
m_base = checkInitProp(m_base, propAddr, propInfo, doWarn, doDefine);
} else {
SSATmp* baseAsObj = nullptr;
m_base = m_tb.cond(m_ht.curFunc(),
[&] (Block* taken) {
// baseAsObj is only available in the Next branch
baseAsObj = gen(LdMem, Type::Obj, taken, m_base, cns(0));
},
[&] { // Next: Base is an object. Load property address and
// check for uninit
return checkInitProp(baseAsObj,
gen(LdPropAddr, baseAsObj,
cns(propInfo.offset)),
propInfo,
doWarn,
doDefine);
},
[&] { // Taken: Base is Null. Raise warnings/errors and return InitNull.
m_tb.hint(Block::Hint::Unlikely);
if (doWarn) {
gen(WarnNonObjProp);
}
if (doDefine) {
/*
* NOTE:
*
* This case logically is supposed to do a stdClass promotion. It
* should ideally not be possible (since we have a known class type),
* except that the static compiler doesn't correctly infer object
* class types in some edge cases involving stdClass promotion.
*
* This is impossible to handle "correctly" if we're in the middle of
* a multi-dim property expression, because things further along may
* also have type inference telling them that object properties are
* at a given slot, but the object could actually be a stdClass
* instead of the knownCls type if we were to promote here.
*
* So, we throw a fatal error, which is what hphpc's generated C++
* would do in this case too.
*
* Relevant TODOs:
* #1789661 (this can cause bugs if bytecode.cpp promotes)
* #1124706 (we want to get rid of stdClass promotion in general)
*/
gen(ThrowNonObjProp);
}
return initNull;
}
);
}
// At this point m_base is either a pointer to init_null_variant or
// a property in the object that we've verified isn't uninit.
assert(m_base->type().isPtr());
}
template <KeyType keyType, bool warn, bool define, bool reffy,
bool unset>
static inline TypedValue* elemImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
if (unset) {
return ElemU<keyType>(mis->tvScratch, mis->tvRef, base, key);
} else if (define) {
return ElemD<warn, reffy, keyType>(mis->tvScratch, mis->tvRef, base, key);
} else {
return Elem<warn, keyType>(mis->tvScratch, mis->tvRef, base, key);
}
}
#define HELPER_TABLE(m) \
/* name hot keyType attrs */ \
m(elemC, , KeyType::Any, None) \
m(elemCD, , KeyType::Any, Define) \
m(elemCDR, , KeyType::Any, DefineReffy) \
m(elemCU, , KeyType::Any, Unset) \
m(elemCW, , KeyType::Any, Warn) \
m(elemCWD, , KeyType::Any, WarnDefine) \
m(elemCWDR, , KeyType::Any, WarnDefineReffy) \
m(elemI, , KeyType::Int, None) \
m(elemID, HOT_FUNC_VM, KeyType::Int, Define) \
m(elemIDR, , KeyType::Int, DefineReffy) \
m(elemIU, , KeyType::Int, Unset) \
m(elemIW, , KeyType::Int, Warn) \
m(elemIWD, , KeyType::Int, WarnDefine) \
m(elemIWDR, , KeyType::Int, WarnDefineReffy) \
m(elemS, HOT_FUNC_VM, KeyType::Str, None) \
m(elemSD, HOT_FUNC_VM, KeyType::Str, Define) \
m(elemSDR, , KeyType::Str, DefineReffy) \
m(elemSU, , KeyType::Str, Unset) \
m(elemSW, HOT_FUNC_VM, KeyType::Str, Warn) \
m(elemSWD, , KeyType::Str, WarnDefine) \
m(elemSWDR, , KeyType::Str, WarnDefineReffy)
#define ELEM(nm, hot, keyType, attrs) \
hot \
TypedValue* nm(TypedValue* base, TypedValue key, MInstrState* mis) { \
return elemImpl<keyType, WDRU(attrs)>(base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitElem() {
MemberCode mCode = m_ni.immVecM[m_mInd];
MInstrAttr mia = MInstrAttr(m_mii.getAttr(mCode) & MIA_intermediate);
SSATmp* key = getKey();
const bool unset = mia & Unset;
const bool define = mia & Define;
assert(!(define && unset));
if (unset) {
SSATmp* uninit = m_tb.genPtrToUninit();
Type baseType = m_base->type().strip();
if (baseType.subtypeOf(Type::Str)) {
m_ht.exceptionBarrier();
gen(
RaiseError,
cns(StringData::GetStaticString(Strings::OP_NOT_SUPPORTED_STRING))
);
m_base = uninit;
return;
}
if (baseType.not(Type::Arr | Type::Obj)) {
m_base = uninit;
return;
}
}
typedef TypedValue* (*OpFunc)(TypedValue*, TypedValue, MInstrState*);
BUILD_OPTAB_HOT(getKeyTypeIS(key), mia);
if (define || unset) {
m_base = genStk(define ? ElemDX : ElemUX, getCatchTrace(),
cns((TCA)opFunc), m_base, key, genMisPtr());
} else {
m_base = gen(ElemX, getCatchTrace(),
cns((TCA)opFunc), m_base, key, genMisPtr());
}
}
#undef HELPER_TABLE
void HhbcTranslator::VectorTranslator::emitNewElem() {
PUNT(emitNewElem);
}
void HhbcTranslator::VectorTranslator::emitRatchetRefs() {
if (ratchetInd() < 0 || ratchetInd() >= int(nLogicalRatchets())) {
return;
}
m_base = m_tb.cond(m_ht.curFunc(),
[&] (Block* taken) {
gen(CheckInitMem, taken, m_misBase, cns(HHIR_MISOFF(tvRef)));
},
[&] { // Next: tvRef isn't Uninit. Ratchet the refs
// Clean up tvRef2 before overwriting it.
if (ratchetInd() > 0) {
gen(DecRefMem, Type::Gen, m_misBase, cns(HHIR_MISOFF(tvRef2)));
}
// Copy tvRef to tvRef2. Use mmx at some point
SSATmp* tvRef = gen(
LdMem, Type::Gen, m_misBase, cns(HHIR_MISOFF(tvRef))
);
gen(StMem, m_misBase, cns(HHIR_MISOFF(tvRef2)), tvRef);
// Reset tvRef.
gen(StMem, m_misBase, cns(HHIR_MISOFF(tvRef)), m_tb.genDefUninit());
// Adjust base pointer.
assert(m_base->type().isPtr());
return gen(LdAddr, m_misBase, cns(HHIR_MISOFF(tvRef2)));
},
[&] { // Taken: tvRef is Uninit. Do nothing.
return m_base;
}
);
}
void HhbcTranslator::VectorTranslator::emitFinalMOp() {
typedef void (HhbcTranslator::VectorTranslator::*MemFun)();
switch (m_ni.immVecM[m_mInd]) {
case MEC: case MEL: case MET: case MEI:
static MemFun elemOps[] = {
# define MII(instr, ...) &HhbcTranslator::VectorTranslator::emit##instr##Elem,
MINSTRS
# undef MII
};
(this->*elemOps[m_mii.instr()])();
break;
case MPC: case MPL: case MPT:
static MemFun propOps[] = {
# define MII(instr, ...) &HhbcTranslator::VectorTranslator::emit##instr##Prop,
MINSTRS
# undef MII
};
(this->*propOps[m_mii.instr()])();
break;
case MW:
assert(m_mii.getAttr(MW) & MIA_final);
static MemFun newOps[] = {
# define MII(instr, attrs, bS, iS, vC, fN) \
&HhbcTranslator::VectorTranslator::emit##fN,
MINSTRS
# undef MII
};
(this->*newOps[m_mii.instr()])();
break;
default: not_reached();
}
}
template <KeyType keyType, bool isObj>
static inline TypedValue cGetPropImpl(Class* ctx, TypedValue* base,
TypedValue keyVal, MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
TypedValue scratch;
TypedValue* result = Prop<true, false, false, isObj, keyType>(
scratch, mis->tvRef, ctx, base, key);
if (result->m_type == KindOfRef) {
result = result->m_data.pref->tv();
}
tvRefcountedIncRef(result);
return *result;
}
#define HELPER_TABLE(m) \
/* name hot keyType isObj */ \
m(cGetPropC, , KeyType::Any, false) \
m(cGetPropCO, , KeyType::Any, true) \
m(cGetPropS, , KeyType::Str, false) \
m(cGetPropSO, HOT_FUNC_VM, KeyType::Str, true)
#define PROP(nm, hot, ...) \
hot \
TypedValue nm(Class* ctx, TypedValue* base, TypedValue key, \
MInstrState* mis) { \
return cGetPropImpl<__VA_ARGS__>(ctx, base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitCGetProp() {
assert(!m_ni.outLocal);
const Class* knownCls = nullptr;
const auto propInfo = getPropertyOffset(m_ni, contextClass(), knownCls,
m_mii, m_mInd, m_iInd);
if (propInfo.offset != -1) {
emitPropSpecialized(MIA_warn, propInfo);
SSATmp* cellPtr = gen(UnboxPtr, m_base);
SSATmp* propVal = gen(LdMem, Type::Cell, cellPtr, cns(0));
m_result = gen(IncRef, propVal);
return;
}
typedef TypedValue (*OpFunc)(Class*, TypedValue*, TypedValue, MInstrState*);
SSATmp* key = getKey();
BUILD_OPTAB_HOT(getKeyTypeS(key), m_base->isA(Type::Obj));
m_result = gen(CGetProp, getCatchTrace(),
cns((TCA)opFunc), CTX(), m_base, key, genMisPtr());
}
#undef HELPER_TABLE
template <KeyType keyType, bool isObj>
static inline RefData* vGetPropImpl(Class* ctx, TypedValue* base,
TypedValue keyVal, MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
TypedValue* result = HPHP::Prop<false, true, false, isObj, keyType>(
mis->tvScratch, mis->tvRef, ctx, base, key);
if (result->m_type != KindOfRef) {
tvBox(result);
}
RefData* ref = result->m_data.pref;
ref->incRefCount();
return ref;
}
#define HELPER_TABLE(m) \
/* name hot keyType isObj */\
m(vGetPropC, , KeyType::Any, false) \
m(vGetPropCO, , KeyType::Any, true) \
m(vGetPropS, , KeyType::Str, false) \
m(vGetPropSO, HOT_FUNC_VM, KeyType::Str, true)
#define PROP(nm, hot, ...) \
hot \
RefData* nm(Class* ctx, TypedValue* base, TypedValue key, \
MInstrState* mis) { \
return vGetPropImpl<__VA_ARGS__>(ctx, base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitVGetProp() {
SSATmp* key = getKey();
typedef RefData* (*OpFunc)(Class*, TypedValue*, TypedValue, MInstrState*);
BUILD_OPTAB_HOT(getKeyTypeS(key), m_base->isA(Type::Obj));
m_result = genStk(VGetProp, getCatchTrace(), cns((TCA)opFunc), CTX(),
m_base, key, genMisPtr());
}
#undef HELPER_TABLE
template <bool useEmpty, bool isObj>
static inline bool issetEmptyPropImpl(Class* ctx, TypedValue* base,
TypedValue keyVal) {
return HPHP::IssetEmptyProp<useEmpty, isObj>(ctx, base, &keyVal);
}
#define HELPER_TABLE(m) \
/* name useEmpty isObj */ \
m(issetPropC, false, false) \
m(issetPropCE, true, false) \
m(issetPropCEO, true, true) \
m(issetPropCO, false, true)
#define ISSET(nm, ...) \
/* This returns int64_t to ensure all 64 bits of rax are valid */ \
uint64_t nm(Class* ctx, TypedValue* base, TypedValue key) { \
return issetEmptyPropImpl<__VA_ARGS__>(ctx, base, key); \
}
namespace VectorHelpers {
HELPER_TABLE(ISSET)
}
#undef ISSET
void HhbcTranslator::VectorTranslator::emitIssetEmptyProp(bool isEmpty) {
SSATmp* key = getKey();
typedef uint64_t (*OpFunc)(Class*, TypedValue*, TypedValue);
BUILD_OPTAB(isEmpty, m_base->isA(Type::Obj));
m_result = gen(isEmpty ? EmptyProp : IssetProp, getCatchTrace(),
cns((TCA)opFunc), CTX(), m_base, key);
}
#undef HELPER_TABLE
void HhbcTranslator::VectorTranslator::emitIssetProp() {
emitIssetEmptyProp(false);
}
void HhbcTranslator::VectorTranslator::emitEmptyProp() {
emitIssetEmptyProp(true);
}
template <bool isObj>
static inline void setPropImpl(Class* ctx, TypedValue* base,
TypedValue keyVal, Cell val) {
HPHP::SetProp<false, isObj>(ctx, base, &keyVal, &val);
}
#define HELPER_TABLE(m) \
/* name isObj */ \
m(setPropC, false) \
m(setPropCO, true)
#define PROP(nm, ...) \
void nm(Class* ctx, TypedValue* base, TypedValue key, Cell val) { \
setPropImpl<__VA_ARGS__>(ctx, base, key, val); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitSetProp() {
SSATmp* value = getValue();
/* If we know the class for the current base, emit a direct property set. */
const Class* knownCls = nullptr;
const auto propInfo = getPropertyOffset(m_ni, contextClass(), knownCls,
m_mii, m_mInd, m_iInd);
if (propInfo.offset != -1) {
emitPropSpecialized(MIA_define, propInfo);
SSATmp* cellPtr = gen(UnboxPtr, m_base);
SSATmp* oldVal = gen(LdMem, Type::Cell, cellPtr, cns(0));
// The object owns a reference now
SSATmp* increffed = gen(IncRef, value);
gen(StMem, cellPtr, cns(0), value);
gen(DecRef, oldVal);
m_result = increffed;
return;
}
// Emit the appropriate helper call.
typedef void (*OpFunc)(Class*, TypedValue*, TypedValue, Cell);
SSATmp* key = getKey();
BUILD_OPTAB(m_base->isA(Type::Obj));
genStk(SetProp, getCatchSetTrace(), cns((TCA)opFunc), CTX(),
m_base, key, value);
m_result = value;
}
#undef HELPER_TABLE
template <bool isObj>
static inline TypedValue setOpPropImpl(TypedValue* base, TypedValue keyVal,
Cell val, MInstrState* mis, SetOpOp op) {
TypedValue* result = HPHP::SetOpProp<isObj>(
mis->tvScratch, mis->tvRef, mis->ctx, op, base, &keyVal, &val);
TypedValue ret;
tvReadCell(result, &ret);
return ret;
}
#define HELPER_TABLE(m) \
/* name isObj */ \
m(setOpPropC, false) \
m(setOpPropCO, true)
#define SETOP(nm, ...) \
TypedValue nm(TypedValue* base, TypedValue key, \
Cell val, MInstrState* mis, SetOpOp op) { \
return setOpPropImpl<__VA_ARGS__>(base, key, val, mis, op); \
}
namespace VectorHelpers {
HELPER_TABLE(SETOP)
}
#undef SETOP
void HhbcTranslator::VectorTranslator::emitSetOpProp() {
SetOpOp op = SetOpOp(m_ni.imm[0].u_OA);
SSATmp* key = getKey();
SSATmp* value = getValue();
typedef TypedValue (*OpFunc)(TypedValue*, TypedValue,
Cell, MInstrState*, SetOpOp);
BUILD_OPTAB(m_base->isA(Type::Obj));
m_tb.gen(StRaw, m_misBase, cns(RawMemSlot::MisCtx), CTX());
m_result =
genStk(SetOpProp, getCatchTrace(), cns((TCA)opFunc),
m_base, key, value, genMisPtr(), cns(op));
}
#undef HELPER_TABLE
template <bool isObj>
static inline TypedValue incDecPropImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis, IncDecOp op) {
TypedValue result;
result.m_type = KindOfUninit;
HPHP::IncDecProp<true, isObj>(
mis->tvScratch, mis->tvRef, mis->ctx, op, base, &keyVal, result);
assert(result.m_type != KindOfRef);
return result;
}
#define HELPER_TABLE(m) \
/* name isObj */ \
m(incDecPropC, false) \
m(incDecPropCO, true)
#define INCDEC(nm, ...) \
TypedValue nm(TypedValue* base, TypedValue key, \
MInstrState* mis, IncDecOp op) { \
return incDecPropImpl<__VA_ARGS__>(base, key, mis, op); \
}
namespace VectorHelpers {
HELPER_TABLE(INCDEC)
}
#undef INCDEC
void HhbcTranslator::VectorTranslator::emitIncDecProp() {
IncDecOp op = IncDecOp(m_ni.imm[0].u_OA);
SSATmp* key = getKey();
typedef TypedValue (*OpFunc)(TypedValue*, TypedValue,
MInstrState*, IncDecOp);
BUILD_OPTAB(m_base->isA(Type::Obj));
m_tb.gen(StRaw, m_misBase, cns(RawMemSlot::MisCtx), CTX());
m_result =
genStk(IncDecProp, getCatchTrace(), cns((TCA)opFunc),
m_base, key, genMisPtr(), cns(op));
}
#undef HELPER_TABLE
template <bool isObj>
static inline void bindPropImpl(Class* ctx, TypedValue* base, TypedValue keyVal,
RefData* val, MInstrState* mis) {
TypedValue* prop = HPHP::Prop<false, true, false, isObj>(
mis->tvScratch, mis->tvRef, ctx, base, &keyVal);
if (!(prop == &mis->tvScratch && prop->m_type == KindOfUninit)) {
tvBindRef(val, prop);
}
}
#define HELPER_TABLE(m) \
/* name isObj */ \
m(bindPropC, false) \
m(bindPropCO, true)
#define PROP(nm, ...) \
void nm(Class* ctx, TypedValue* base, TypedValue key, \
RefData* val, MInstrState* mis) { \
bindPropImpl<__VA_ARGS__>(ctx, base, key, val, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitBindProp() {
SSATmp* key = getKey();
SSATmp* box = getValue();
typedef void (*OpFunc)(Class*, TypedValue*, TypedValue, RefData*,
MInstrState*);
BUILD_OPTAB(m_base->isA(Type::Obj));
genStk(BindProp, getCatchTrace(), cns((TCA)opFunc), CTX(),
m_base, key, box, genMisPtr());
m_result = box;
}
#undef HELPER_TABLE
template <bool isObj>
static inline void unsetPropImpl(Class* ctx, TypedValue* base,
TypedValue keyVal) {
HPHP::UnsetProp<isObj>(ctx, base, &keyVal);
}
#define HELPER_TABLE(m) \
/* name isObj */ \
m(unsetPropC, false) \
m(unsetPropCO, true)
#define PROP(nm, ...) \
static void nm(Class* ctx, TypedValue* base, TypedValue key) { \
unsetPropImpl<__VA_ARGS__>(ctx, base, key); \
}
namespace VectorHelpers {
HELPER_TABLE(PROP)
}
#undef PROP
void HhbcTranslator::VectorTranslator::emitUnsetProp() {
SSATmp* key = getKey();
if (m_base->type().strip().not(Type::Obj)) {
// Noop
return;
}
typedef void (*OpFunc)(Class*, TypedValue*, TypedValue);
BUILD_OPTAB(m_base->isA(Type::Obj));
gen(UnsetProp, cns((TCA)opFunc), CTX(), m_base, key);
}
#undef HELPER_TABLE
// Keep these error handlers in sync with ArrayData::getNotFound();
NEVER_INLINE
static TypedValue arrayGetNotFound(int64_t k) {
raise_notice("Undefined index: %" PRId64, k);
TypedValue v;
tvWriteNull(&v);
return v;
}
NEVER_INLINE
static TypedValue arrayGetNotFound(const StringData* k) {
raise_notice("Undefined index: %s", k->data());
TypedValue v;
tvWriteNull(&v);
return v;
}
static inline TypedValue* checkedGet(ArrayData* a, StringData* key) {
int64_t i;
return UNLIKELY(key->isStrictlyInteger(i)) ? a->nvGet(i) : a->nvGet(key);
}
static inline TypedValue* checkedGet(ArrayData* a, int64_t key) {
not_reached();
}
template<KeyType keyType, bool checkForInt>
static inline TypedValue arrayGetImpl(
ArrayData* a, typename KeyTypeTraits<keyType>::rawType key) {
TypedValue* ret = checkForInt ? checkedGet(a, key)
: a->nvGet(key);
if (ret) {
ret = tvToCell(ret);
tvRefcountedIncRef(ret);
return *ret;
}
return arrayGetNotFound(key);
}
#define HELPER_TABLE(m) \
/* name hot keyType checkForInt */\
m(arrayGetS, HOT_FUNC_VM, KeyType::Str, false) \
m(arrayGetSi, HOT_FUNC_VM, KeyType::Str, true) \
m(arrayGetI, HOT_FUNC_VM, KeyType::Int, false)
#define ELEM(nm, hot, keyType, checkForInt) \
hot \
TypedValue nm(ArrayData* a, TypedValue* key) { \
return arrayGetImpl<keyType, checkForInt>(a, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitArrayGet(SSATmp* key) {
KeyType keyType;
bool checkForInt;
m_ht.checkStrictlyInteger(key, keyType, checkForInt);
typedef TypedValue (*OpFunc)(ArrayData*, TypedValue*);
BUILD_OPTAB_HOT(keyType, checkForInt);
assert(m_base->isA(Type::Arr));
m_result = gen(ArrayGet, cns((TCA)opFunc), m_base, key);
}
#undef HELPER_TABLE
namespace VectorHelpers {
TypedValue vectorGet(c_Vector* vec, int64_t key) {
TypedValue* ret = vec->at(key);
return *ret;
}
}
void HhbcTranslator::VectorTranslator::emitVectorGet(SSATmp* key) {
SSATmp* value = gen(VectorGet, getCatchTrace(),
cns((TCA)VectorHelpers::vectorGet), m_base, key);
m_result = gen(IncRef, value);
}
namespace VectorHelpers {
TypedValue pairGet(c_Pair* pair, int64_t key) {
TypedValue* ret = pair->at(key);
return *ret;
}
}
void HhbcTranslator::VectorTranslator::emitPairGet(SSATmp* key) {
SSATmp* value = gen(PairGet, getCatchTrace(),
cns((TCA)VectorHelpers::pairGet), m_base, key);
m_result = gen(IncRef, value);
}
template<KeyType keyType>
static inline TypedValue mapGetImpl(
c_Map* map, typename KeyTypeTraits<keyType>::rawType key) {
TypedValue* ret = map->at(key);
return *ret;
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(mapGetS, HOT_FUNC_VM, KeyType::Str) \
m(mapGetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
TypedValue nm(c_Map* map, TypedValue* key) { \
return mapGetImpl<keyType>(map, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitMapGet(SSATmp* key) {
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_Map*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
SSATmp* value = gen(MapGet, getCatchTrace(),
cns((TCA)opFunc), m_base, key);
m_result = gen(IncRef, value);
}
#undef HELPER_TABLE
template<KeyType keyType>
static inline TypedValue stableMapGetImpl(
c_StableMap* map, typename KeyTypeTraits<keyType>::rawType key) {
TypedValue* ret = map->at(key);
return *ret;
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(stableMapGetS, HOT_FUNC_VM, KeyType::Str) \
m(stableMapGetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
TypedValue nm(c_StableMap* map, TypedValue* key) { \
return stableMapGetImpl<keyType>(map, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitStableMapGet(SSATmp* key) {
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_StableMap*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
SSATmp* value = gen(StableMapGet, getCatchTrace(),
cns((TCA)opFunc), m_base, key);
m_result = gen(IncRef, value);
}
#undef HELPER_TABLE
template <KeyType keyType>
static inline TypedValue cGetElemImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
TypedValue scratch;
TypedValue* result = Elem<true, keyType>(scratch, mis->tvRef, base, key);
if (result->m_type == KindOfRef) {
result = result->m_data.pref->tv();
}
tvRefcountedIncRef(result);
return *result;
}
#define HELPER_TABLE(m) \
/* name hot key */ \
m(cGetElemC, , KeyType::Any) \
m(cGetElemI, , KeyType::Int) \
m(cGetElemS, HOT_FUNC_VM, KeyType::Str)
#define ELEM(nm, hot, ...) \
hot \
TypedValue nm(TypedValue* base, TypedValue key, MInstrState* mis) { \
return cGetElemImpl<__VA_ARGS__>(base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitCGetElem() {
SSATmp* key = getKey();
SimpleOp simpleOpType = isSimpleCollectionOp();
switch (simpleOpType) {
case SimpleOp::Array:
emitArrayGet(key);
break;
case SimpleOp::Vector:
emitVectorGet(key);
break;
case SimpleOp::Pair:
emitPairGet(key);
break;
case SimpleOp::Map:
emitMapGet(key);
break;
case SimpleOp::StableMap:
emitStableMapGet(key);
break;
default:
typedef TypedValue (*OpFunc)(TypedValue*, TypedValue, MInstrState*);
BUILD_OPTAB_HOT(getKeyTypeIS(key));
m_result = gen(CGetElem, getCatchTrace(), cns((TCA)opFunc),
m_base, key, genMisPtr());
break;
}
}
#undef HELPER_TABLE
template <KeyType keyType>
static inline RefData* vGetElemImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
TypedValue* result = HPHP::ElemD<false, true, keyType>(
mis->tvScratch, mis->tvRef, base, key);
if (result->m_type != KindOfRef) {
tvBox(result);
}
RefData* ref = result->m_data.pref;
ref->incRefCount();
return ref;
}
#define HELPER_TABLE(m) \
/* name keyType */ \
m(vGetElemC, KeyType::Any) \
m(vGetElemI, KeyType::Int) \
m(vGetElemS, KeyType::Str)
#define ELEM(nm, ...) \
RefData* nm(TypedValue* base, TypedValue key, MInstrState* mis) { \
return vGetElemImpl<__VA_ARGS__>(base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitVGetElem() {
SSATmp* key = getKey();
typedef RefData* (*OpFunc)(TypedValue*, TypedValue, MInstrState*);
BUILD_OPTAB(getKeyTypeIS(key));
m_result = genStk(VGetElem, getCatchTrace(), cns((TCA)opFunc),
m_base, key, genMisPtr());
}
#undef HELPER_TABLE
template <KeyType keyType, bool isEmpty>
static inline bool issetEmptyElemImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis) {
TypedValue* key = keyPtr<keyType>(keyVal);
// mis == nullptr if we proved that it won't be used. mis->tvScratch and
// mis->tvRef are ok because those params are passed by
// reference.
return HPHP::IssetEmptyElem<isEmpty, false, keyType>(
mis->tvScratch, mis->tvRef, base, key);
}
#define HELPER_TABLE(m) \
/* name hot keyType isEmpty */\
m(issetElemC, , KeyType::Any, false) \
m(issetElemCE, , KeyType::Any, true) \
m(issetElemI, HOT_FUNC_VM, KeyType::Int, false) \
m(issetElemIE, , KeyType::Int, true) \
m(issetElemS, HOT_FUNC_VM, KeyType::Str, false) \
m(issetElemSE, , KeyType::Str, true)
#define ISSET(nm, hot, ...) \
hot \
uint64_t nm(TypedValue* base, TypedValue key, MInstrState* mis) { \
return issetEmptyElemImpl<__VA_ARGS__>(base, key, mis); \
}
namespace VectorHelpers {
HELPER_TABLE(ISSET)
}
#undef ISSET
void HhbcTranslator::VectorTranslator::emitIssetEmptyElem(bool isEmpty) {
SSATmp* key = getKey();
typedef uint64_t (*OpFunc)(TypedValue*, TypedValue, MInstrState*);
BUILD_OPTAB_HOT(getKeyTypeIS(key), isEmpty);
m_result = gen(isEmpty ? EmptyElem : IssetElem, getCatchTrace(),
cns((TCA)opFunc), m_base, key, genMisPtr());
}
#undef HELPER_TABLE
template<KeyType keyType, bool checkForInt>
static inline uint64_t arrayIssetImpl(
ArrayData* a, typename KeyTypeTraits<keyType>::rawType key) {
TypedValue* value = checkForInt ? checkedGet(a, key)
: a->nvGet(key);
Variant* var = &tvAsVariant(value);
return var && !var->isNull();
}
#define HELPER_TABLE(m) \
/* name keyType checkForInt */\
m(arrayIssetS, KeyType::Str, false) \
m(arrayIssetSi, KeyType::Str, true) \
m(arrayIssetI, KeyType::Int, false)
#define ISSET(nm, keyType, checkForInt) \
uint64_t nm(ArrayData* a, TypedValue* key) { \
return arrayIssetImpl<keyType, checkForInt>(a, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ISSET)
}
#undef ISSET
void HhbcTranslator::VectorTranslator::emitArrayIsset() {
SSATmp* key = getKey();
KeyType keyType;
bool checkForInt;
m_ht.checkStrictlyInteger(key, keyType, checkForInt);
typedef uint64_t (*OpFunc)(ArrayData*, TypedValue*);
BUILD_OPTAB(keyType, checkForInt);
assert(m_base->isA(Type::Arr));
m_result = gen(ArrayIsset, getCatchTrace(),
cns((TCA)opFunc), m_base, key);
}
#undef HELPER_TABLE
namespace VectorHelpers {
uint64_t vectorIsset(c_Vector* vec, int64_t index) {
return vec->get(index) != nullptr;
}
}
void HhbcTranslator::VectorTranslator::emitVectorIsset() {
SSATmp* key = getKey();
assert(key->isA(Type::Int));
m_result = gen(VectorIsset,
cns((TCA)VectorHelpers::vectorIsset),
m_base,
key);
}
namespace VectorHelpers {
uint64_t pairIsset(c_Pair* pair, int64_t index) {
return pair->get(index) != nullptr;
}
}
void HhbcTranslator::VectorTranslator::emitPairIsset() {
SSATmp* key = getKey();
assert(key->isA(Type::Int));
m_result = gen(PairIsset,
cns((TCA)VectorHelpers::pairIsset),
m_base,
key);
}
template<KeyType keyType>
static inline uint64_t mapIssetImpl(
c_Map* map, typename KeyTypeTraits<keyType>::rawType key) {
return map->get(key) != nullptr;
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(mapIssetS, HOT_FUNC_VM, KeyType::Str) \
m(mapIssetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
uint64_t nm(c_Map* map, TypedValue* key) { \
return mapIssetImpl<keyType>(map, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitMapIsset() {
SSATmp* key = getKey();
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_Map*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
m_result = gen(MapIsset, cns((TCA)opFunc), m_base, key);
}
#undef HELPER_TABLE
template<KeyType keyType>
static inline uint64_t stableMapIssetImpl(
c_StableMap* map, typename KeyTypeTraits<keyType>::rawType key) {
return map->get(key) != nullptr;
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(stableMapIssetS, HOT_FUNC_VM, KeyType::Str) \
m(stableMapIssetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
uint64_t nm(c_StableMap* map, TypedValue* key) { \
return stableMapIssetImpl<keyType>(map, keyAsRaw<keyType>(key)); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitStableMapIsset() {
SSATmp* key = getKey();
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_StableMap*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
m_result = gen(StableMapIsset, cns((TCA)opFunc), m_base, key);
}
#undef HELPER_TABLE
void HhbcTranslator::VectorTranslator::emitIssetElem() {
SimpleOp simpleOpType = isSimpleCollectionOp();
switch (simpleOpType) {
case SimpleOp::Array:
emitArrayIsset();
break;
case SimpleOp::Vector:
emitVectorIsset();
break;
case SimpleOp::Pair:
emitPairIsset();
break;
case SimpleOp::Map:
emitMapIsset();
break;
case SimpleOp::StableMap:
emitStableMapIsset();
break;
default:
emitIssetEmptyElem(false);
break;
}
}
void HhbcTranslator::VectorTranslator::emitEmptyElem() {
emitIssetEmptyElem(true);
}
static inline ArrayData* checkedSet(ArrayData* a, StringData* key,
CVarRef value, bool copy) {
int64_t i;
return UNLIKELY(key->isStrictlyInteger(i)) ? a->set(i, value, copy)
: a->set(key, value, copy);
}
static inline ArrayData* checkedSet(ArrayData* a, int64_t key,
CVarRef value, bool copy) {
not_reached();
}
template<KeyType keyType, bool checkForInt, bool setRef>
static inline typename ShuffleReturn<setRef>::return_type arraySetImpl(
ArrayData* a, typename KeyTypeTraits<keyType>::rawType key,
CVarRef value, RefData* ref) {
static_assert(keyType != KeyType::Any,
"KeyType::Any is not supported in arraySetMImpl");
const bool copy = a->getCount() > 1;
ArrayData* ret = checkForInt ? checkedSet(a, key, value, copy)
: a->set(key, value, copy);
return arrayRefShuffle<setRef>(a, ret, setRef ? ref->tv() : nullptr);
}
#define HELPER_TABLE(m) \
/* name hot keyType checkForInt setRef */ \
m(arraySetS, HOT_FUNC_VM, KeyType::Str, false, false) \
m(arraySetSi, HOT_FUNC_VM, KeyType::Str, true, false) \
m(arraySetI, HOT_FUNC_VM, KeyType::Int, false, false) \
m(arraySetSR, , KeyType::Str, false, true) \
m(arraySetSiR, , KeyType::Str, true, true) \
m(arraySetIR, , KeyType::Int, false, true)
#define ELEM(nm, hot, keyType, checkForInt, setRef) \
hot \
typename ShuffleReturn<setRef>::return_type \
nm(ArrayData* a, TypedValue* key, TypedValue value, RefData* ref) { \
return arraySetImpl<keyType, checkForInt, setRef>( \
a, keyAsRaw<keyType>(key), tvAsCVarRef(&value), ref); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitArraySet(SSATmp* key,
SSATmp* value) {
assert(m_iInd == m_mii.valCount() + 1);
const int baseStkIdx = m_mii.valCount();
assert(key->type().notBoxed());
assert(value->type().notBoxed());
KeyType keyType;
bool checkForInt;
m_ht.checkStrictlyInteger(key, keyType, checkForInt);
const DynLocation& base = *m_ni.inputs[m_mii.valCount()];
bool setRef = base.outerType() == KindOfRef;
typedef ArrayData* (*OpFunc)(ArrayData*, TypedValue*, TypedValue, RefData*);
BUILD_OPTAB_HOT(keyType, checkForInt, setRef);
// No catch trace below because the helper can't throw. It may reenter to
// call destructors so it has a sync point in nativecalls.cpp, but exceptions
// are swallowed at destructor boundaries right now: #2182869.
if (setRef) {
assert(base.location.space == Location::Local ||
base.location.space == Location::Stack);
SSATmp* box = getInput(baseStkIdx);
gen(ArraySetRef, cns((TCA)opFunc), m_base, key, value, box);
// Unlike the non-ref case, we don't need to do anything to the stack
// because any load of the box will be guarded.
} else {
SSATmp* newArr = gen(ArraySet, cns((TCA)opFunc), m_base, key, value);
// Update the base's value with the new array
if (base.location.space == Location::Local) {
// We know it's not boxed (setRef above handles that), and
// newArr has already been incref'd in the helper.
gen(StLoc, LocalId(base.location.offset), m_tb.fp(), newArr);
} else if (base.location.space == Location::Stack) {
VectorEffects ve(newArr->inst());
assert(ve.baseValChanged);
assert(ve.baseType.subtypeOf(Type::Arr));
m_ht.extendStack(baseStkIdx, Type::Gen);
m_ht.replace(baseStkIdx, newArr);
} else {
not_reached();
}
}
m_result = value;
}
#undef HELPER_TABLE
namespace VectorHelpers {
void setWithRefElemC(TypedValue* base, TypedValue keyVal, TypedValue* val,
MInstrState* mis) {
base = HPHP::ElemD<false, false>(mis->tvScratch, mis->tvRef, base, &keyVal);
if (base != &mis->tvScratch) {
tvDup(*val, *base);
} else {
assert(base->m_type == KindOfUninit);
}
}
void setWithRefNewElem(TypedValue* base, TypedValue* val,
MInstrState* mis) {
base = NewElem(mis->tvScratch, mis->tvRef, base);
if (base != &mis->tvScratch) {
tvDup(*val, *base);
} else {
assert(base->m_type == KindOfUninit);
}
}
}
void HhbcTranslator::VectorTranslator::emitSetWithRefLElem() {
SSATmp* key = getKey();
SSATmp* locAddr = getValAddr();
if (m_base->type().strip().subtypeOf(Type::Arr) &&
!locAddr->type().deref().maybeBoxed()) {
emitSetElem();
assert(m_strTestResult == nullptr);
} else {
genStk(SetWithRefElem, getCatchTrace(),
cns((TCA)VectorHelpers::setWithRefElemC),
m_base, key, locAddr, genMisPtr());
}
m_result = nullptr;
}
void HhbcTranslator::VectorTranslator::emitSetWithRefLProp() {
SPUNT(__func__);
}
void HhbcTranslator::VectorTranslator::emitSetWithRefRElem() {
emitSetWithRefLElem();
}
void HhbcTranslator::VectorTranslator::emitSetWithRefRProp() {
emitSetWithRefLProp();
}
void HhbcTranslator::VectorTranslator::emitSetWithRefNewElem() {
if (m_base->type().strip().subtypeOf(Type::Arr) &&
getValue()->type().notBoxed()) {
emitSetNewElem();
} else {
genStk(SetWithRefNewElem, getCatchTrace(),
cns((TCA)VectorHelpers::setWithRefNewElem),
m_base, getValAddr(), genMisPtr());
}
m_result = nullptr;
}
namespace VectorHelpers {
void vectorSet(c_Vector* vec, int64_t key, Cell value) {
vec->set(key, &value);
}
}
void HhbcTranslator::VectorTranslator::emitVectorSet(
SSATmp* key, SSATmp* value) {
gen(VectorSet, getCatchTrace(),
cns((TCA)VectorHelpers::vectorSet), m_base, key, value);
m_result = value;
}
template<KeyType keyType>
static inline void mapSetImpl(
c_Map* map,
typename KeyTypeTraits<keyType>::rawType key,
Cell value) {
map->set(key, &value);
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(mapSetS, HOT_FUNC_VM, KeyType::Str) \
m(mapSetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
void nm(c_Map* map, TypedValue* key, Cell value) { \
mapSetImpl<keyType>(map, keyAsRaw<keyType>(key), value); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitMapSet(
SSATmp* key, SSATmp* value) {
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_Map*, TypedValue*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
gen(MapSet, getCatchTrace(),
cns((TCA)opFunc), m_base, key, value);
m_result = value;
}
#undef HELPER_TABLE
template<KeyType keyType>
static inline void stableMapSetImpl(
c_StableMap* map,
typename KeyTypeTraits<keyType>::rawType key,
Cell value) {
map->set(key, &value);
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(stableMapSetS, HOT_FUNC_VM, KeyType::Str) \
m(stableMapSetI, HOT_FUNC_VM, KeyType::Int)
#define ELEM(nm, hot, keyType) \
hot \
void nm(c_StableMap* map, TypedValue* key, Cell value) { \
stableMapSetImpl<keyType>(map, keyAsRaw<keyType>(key), value); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitStableMapSet(
SSATmp* key, SSATmp* value) {
assert(key->isA(Type::Int) || key->isA(Type::Str));
KeyType keyType = key->isA(Type::Int) ? KeyType::Int : KeyType::Str;
typedef TypedValue (*OpFunc)(c_StableMap*, TypedValue*, TypedValue*);
BUILD_OPTAB_HOT(keyType);
gen(StableMapSet, getCatchTrace(),
cns((TCA)opFunc), m_base, key, value);
m_result = value;
}
#undef HELPER_TABLE
template <KeyType keyType>
static inline StringData* setElemImpl(TypedValue* base, TypedValue keyVal,
Cell val) {
TypedValue* key = keyPtr<keyType>(keyVal);
return HPHP::SetElem<false, keyType>(base, key, &val);
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(setElemC, , KeyType::Any) \
m(setElemI, , KeyType::Int) \
m(setElemS, HOT_FUNC_VM, KeyType::Str)
#define ELEM(nm, hot, ...) \
hot \
StringData* nm(TypedValue* base, TypedValue key, Cell val) { \
return setElemImpl<__VA_ARGS__>(base, key, val); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitSetElem() {
SSATmp* value = getValue();
SSATmp* key = getKey();
SimpleOp simpleOpType = isSimpleCollectionOp();
switch (simpleOpType) {
case SimpleOp::Array:
emitArraySet(key, value);
break;
case SimpleOp::Vector:
emitVectorSet(key, value);
break;
case SimpleOp::Map:
emitMapSet(key, value);
break;
case SimpleOp::StableMap:
emitStableMapSet(key, value);
break;
default:
// Emit the appropriate helper call.
typedef StringData* (*OpFunc)(TypedValue*, TypedValue, Cell);
BUILD_OPTAB_HOT(getKeyTypeIS(key));
m_failedSetTrace = getCatchSetTrace();
SSATmp* result = genStk(SetElem, m_failedSetTrace, cns((TCA)opFunc),
m_base, key, value);
auto t = result->type();
if (t.equals(Type::Nullptr)) {
// Base is not a string. Result is always value.
m_result = value;
} else if (t.equals(Type::CountedStr)) {
// Base is a string. Stack result is a new string so we're responsible for
// decreffing value.
m_result = result;
gen(DecRef, value);
} else {
assert(t.equals(Type::CountedStr | Type::Nullptr));
// Base might be a string. Assume the result is value, then inform
// emitMPost that it needs to test the actual result.
m_result = value;
m_strTestResult = result;
}
break;
}
}
#undef HELPER_TABLE
template <SetOpOp op>
static inline TypedValue setOpElemImpl(TypedValue* base, TypedValue keyVal,
Cell val, MInstrState* mis) {
TypedValue* result =
HPHP::SetOpElem(mis->tvScratch, mis->tvRef, op, base, &keyVal, &val);
TypedValue ret;
tvReadCell(result, &ret);
return ret;
}
#define OPELEM_TABLE(m, nm, op) \
/* name op */ \
m(nm##op##ElemC, op)
#define HELPER_TABLE(m, op) OPELEM_TABLE(m, setOp, SetOp##op)
#define SETOP(nm, ...) \
TypedValue nm(TypedValue* base, TypedValue key, Cell val, \
MInstrState* mis) { \
return setOpElemImpl<__VA_ARGS__>(base, key, val, mis); \
}
#define SETOP_OP(op, bcOp) HELPER_TABLE(SETOP, op)
namespace VectorHelpers {
SETOP_OPS
}
#undef SETOP_OP
#undef SETOP
void HhbcTranslator::VectorTranslator::emitSetOpElem() {
SetOpOp op = SetOpOp(m_ni.imm[0].u_OA);
SSATmp* key = getKey();
typedef TypedValue (*OpFunc)(TypedValue*, TypedValue, Cell, MInstrState*);
# define SETOP_OP(op, bcOp) HELPER_TABLE(FILL_ROW, op)
BUILD_OPTAB_ARG(SETOP_OPS, op);
# undef SETOP_OP
m_result =
genStk(SetOpElem, getCatchTrace(), cns((TCA)opFunc),
m_base, key, getValue(), genMisPtr());
}
#undef HELPER_TABLE
template <IncDecOp op>
static inline TypedValue incDecElemImpl(TypedValue* base, TypedValue keyVal,
MInstrState* mis) {
TypedValue result;
HPHP::IncDecElem<true>(
mis->tvScratch, mis->tvRef, op, base, &keyVal, result);
assert(result.m_type != KindOfRef);
return result;
}
#define HELPER_TABLE(m, op) OPELEM_TABLE(m, incDec, op)
#define INCDEC(nm, ...) \
TypedValue nm(TypedValue* base, TypedValue key, MInstrState* mis) { \
return incDecElemImpl<__VA_ARGS__>(base, key, mis); \
}
#define INCDEC_OP(op) HELPER_TABLE(INCDEC, op)
namespace VectorHelpers {
INCDEC_OPS
}
#undef INCDEC_OP
#undef INCDEC
void HhbcTranslator::VectorTranslator::emitIncDecElem() {
IncDecOp op = IncDecOp(m_ni.imm[0].u_OA);
SSATmp* key = getKey();
typedef TypedValue (*OpFunc)(TypedValue*, TypedValue, MInstrState*);
# define INCDEC_OP(op) HELPER_TABLE(FILL_ROW, op)
BUILD_OPTAB_ARG(INCDEC_OPS, op);
# undef INCDEC_OP
m_result = genStk(IncDecElem, getCatchTrace(), cns((TCA)opFunc),
m_base, key, genMisPtr());
}
#undef HELPER_TABLE
namespace VectorHelpers {
void bindElemC(TypedValue* base, TypedValue keyVal, RefData* val,
MInstrState* mis) {
base = HPHP::ElemD<false, true>(mis->tvScratch, mis->tvRef, base, &keyVal);
if (!(base == &mis->tvScratch && base->m_type == KindOfUninit)) {
tvBindRef(val, base);
}
}
}
void HhbcTranslator::VectorTranslator::emitBindElem() {
SSATmp* key = getKey();
SSATmp* box = getValue();
genStk(BindElem, getCatchTrace(), cns((TCA)VectorHelpers::bindElemC),
m_base, key, box, genMisPtr());
m_result = box;
}
template <KeyType keyType>
static inline void unsetElemImpl(TypedValue* base, TypedValue keyVal) {
TypedValue* key = keyPtr<keyType>(keyVal);
HPHP::UnsetElem<keyType>(base, key);
}
#define HELPER_TABLE(m) \
/* name hot keyType */ \
m(unsetElemC, , KeyType::Any) \
m(unsetElemI, , KeyType::Int) \
m(unsetElemS, HOT_FUNC_VM, KeyType::Str)
#define ELEM(nm, hot, ...) \
hot \
void nm(TypedValue* base, TypedValue key) { \
unsetElemImpl<__VA_ARGS__>(base, key); \
}
namespace VectorHelpers {
HELPER_TABLE(ELEM)
}
#undef ELEM
void HhbcTranslator::VectorTranslator::emitUnsetElem() {
SSATmp* key = getKey();
Type baseType = m_base->type().strip();
if (baseType.subtypeOf(Type::Str)) {
m_ht.exceptionBarrier();
gen(RaiseError,
cns(StringData::GetStaticString(Strings::CANT_UNSET_STRING)));
return;
}
if (baseType.not(Type::Arr | Type::Obj)) {
// Noop
return;
}
typedef void (*OpFunc)(TypedValue*, TypedValue);
BUILD_OPTAB_HOT(getKeyTypeIS(key));
genStk(UnsetElem, getCatchTrace(), cns((TCA)opFunc), m_base, key);
}
#undef HELPER_TABLE
void HhbcTranslator::VectorTranslator::emitNotSuppNewElem() {
not_reached();
}
void HhbcTranslator::VectorTranslator::emitVGetNewElem() {
SPUNT(__func__);
}
void HhbcTranslator::VectorTranslator::emitSetNewElem() {
SSATmp* value = getValue();
gen(SetNewElem, getCatchSetTrace(), m_base, value);
m_result = value;
}
void HhbcTranslator::VectorTranslator::emitSetOpNewElem() {
SPUNT(__func__);
}
void HhbcTranslator::VectorTranslator::emitIncDecNewElem() {
SPUNT(__func__);
}
void HhbcTranslator::VectorTranslator::emitBindNewElem() {
SSATmp* box = getValue();
genStk(BindNewElem, getCatchTrace(), m_base, box, genMisPtr());
m_result = box;
}
void HhbcTranslator::VectorTranslator::emitMPost() {
SSATmp* catchSp = nullptr;
if (m_failedSetTrace) {
catchSp = m_failedSetTrace->back()->back()->src(0);
assert(catchSp->isA(Type::StkPtr));
}
// Decref stack inputs. If we're translating a SetM or BindM, then input 0 is
// both our input and output so leave its refcount alone. If m_failedSetTrace
// is non-null, the final helper call may throw an InvalidSetMException. We
// need to add instructions to m_failedSetTrace to finish the vector
// instruction in case this happens, so any DecRefs emitted here are also
// added to m_failedSetTrace.
unsigned nStack =
(m_ni.mInstrOp() == OpSetM || m_ni.mInstrOp() == OpBindM) ? 1 : 0;
for (unsigned i = nStack; i < m_ni.inputs.size(); ++i) {
const DynLocation& input = *m_ni.inputs[i];
switch (input.location.space) {
case Location::Stack: {
++nStack;
auto input = getInput(i);
if (input->isA(Type::Gen)) {
gen(DecRef, input);
if (m_failedSetTrace) {
TracePusher tp(m_tb, m_failedSetTrace, m_marker);
gen(DecRefStack, StackOffset(m_stackInputs[i]), Type::Cell, catchSp);
}
}
break;
}
case Location::Local:
case Location::Litstr:
case Location::Litint:
case Location::This: {
// Do nothing.
break;
}
default: not_reached();
}
}
// Pop off all stack inputs
m_ht.discard(nStack);
// Push result, if one was produced. If we have a predicted result use that
// instead of the real result; its validity will be guarded later in this
// function.
if (m_result) {
m_ht.push(m_result);
} else {
assert(m_ni.mInstrOp() == OpUnsetM ||
m_ni.mInstrOp() == OpSetWithRefLM ||
m_ni.mInstrOp() == OpSetWithRefRM);
}
// Clean up tvRef(2): during exception handling any objects required only
// during vector expansion need to be DecRef'd. There may be either one
// or two such scratch objects, in the case of a Set the first of which will
// always be tvRef2, in all other cases if only one scratch value is present
// it will be stored in tvRef.
static const size_t refOffs[] = { HHIR_MISOFF(tvRef), HHIR_MISOFF(tvRef2) };
for (unsigned i = 0; i < std::min(nLogicalRatchets(), 2U); ++i) {
IRInstruction* inst = m_irf.gen(DecRefMem, m_marker, Type::Gen, m_misBase,
cns(refOffs[m_failedSetTrace ? 1 - i : i]));
m_tb.add(inst);
prependToTraces(inst);
}
emitSideExits(catchSp, nStack);
}
void HhbcTranslator::VectorTranslator::emitSideExits(SSATmp* catchSp,
int nStack) {
auto const nextOff = m_ht.nextBcOff();
auto const op = m_ni.mInstrOp();
const bool isSetWithRef = op == OpSetWithRefLM || op == OpSetWithRefRM;
if (m_failedSetTrace) {
assert(bool(m_result) ^ isSetWithRef);
// This catch trace currently ends with an EndCatch that will fall through
// if an InvalidSetMException was thrown. We need to emit code to clean up
// if that happens. If we're translating a SetWithRef* bytecode we don't
// have to do anything special to the stack since they have no stack
// output. Otherwise we need to pop our input value and push the value from
// the exception to the stack (done with a DecRefStack followed by a
// SpillStack).
std::vector<SSATmp*> args{
catchSp, // sp from the previous SpillStack
cns(nStack), // cells popped since the last SpillStack
};
TracePusher tp(m_tb, m_failedSetTrace, m_marker);
if (!isSetWithRef) {
gen(DecRefStack, StackOffset(0), Type::Cell, catchSp);
args.push_back(m_ht.gen(LdUnwinderValue, Type::Cell));
}
SSATmp* sp = gen(SpillStack, std::make_pair(args.size(), &args[0]));
gen(DeleteUnwinderException);
gen(SyncABIRegs, m_tb.fp(), sp);
gen(ReqBindJmp, BCOffset(nextOff));
}
if (m_strTestResult) {
assert(!isSetWithRef);
// We expected SetElem's base to not be a Str but might be wrong. Make an
// exit trace to side exit to the next instruction, replacing our guess
// with the correct stack output.
auto toSpill = m_ht.peekSpillValues();
assert(toSpill.size());
assert(toSpill[0] == m_result);
SSATmp* str = m_irf.gen(AssertNonNull, m_marker, m_strTestResult)->dst();
toSpill[0] = str;
auto exitTrace = m_ht.getExitTrace(nextOff, toSpill);
{
TracePusher tp(m_tb, exitTrace, m_marker, exitTrace->back(),
exitTrace->back()->skipHeader());
gen(IncStat, cns(Stats::TC_SetMStrGuess_Miss), cns(1), cns(false));
gen(DecRef, m_result);
m_tb.add(str->inst());
}
gen(CheckType, Type::Nullptr, exitTrace, m_strTestResult);
gen(IncStat, cns(Stats::TC_SetMStrGuess_Hit), cns(1), cns(false));
}
}
bool HhbcTranslator::VectorTranslator::needFirstRatchet() const {
if (m_ni.inputs[m_mii.valCount()]->valueType() == KindOfArray) {
switch (m_ni.immVecM[0]) {
case MEC: case MEL: case MET: case MEI: return false;
case MPC: case MPL: case MPT: case MW: return true;
default: not_reached();
}
}
return true;
}
bool HhbcTranslator::VectorTranslator::needFinalRatchet() const {
return m_mii.finalGet();
}
// Ratchet operations occur after each intermediate operation, except
// possibly the first and last (see need{First,Final}Ratchet()). No actual
// ratchet occurs after the final operation, but this means that both tvRef
// and tvRef2 can contain references just after the final operation. Here we
// pretend that a ratchet occurs after the final operation, i.e. a "logical"
// ratchet. The reason for counting logical ratchets as part of the total is
// the following case, in which the logical count is 0:
//
// (base is array)
// BaseL
// IssetElemL
// no logical ratchet
//
// Following are a few more examples to make the algorithm clear:
//
// (base is array) (base is object) (base is object)
// BaseL BaseL BaseL
// ElemL ElemL CGetPropL
// no ratchet ratchet logical ratchet
// ElemL PropL
// ratchet ratchet
// ElemL CGetElemL
// ratchet logical ratchet
// IssetElemL
// logical ratchet
//
// (base is array)
// BaseL
// ElemL
// no ratchet
// ElemL
// ratchet
// ElemL
// logical ratchet
// SetElemL
// no ratchet
unsigned HhbcTranslator::VectorTranslator::nLogicalRatchets() const {
// If we've proven elsewhere that we don't need an MInstrState struct, we
// know this translation won't need any ratchets
if (!m_needMIS) return 0;
unsigned ratchets = m_ni.immVecM.size();
if (!needFirstRatchet()) --ratchets;
if (!needFinalRatchet()) --ratchets;
return ratchets;
}
int HhbcTranslator::VectorTranslator::ratchetInd() const {
return needFirstRatchet() ? int(m_mInd) : int(m_mInd) - 1;
}
} }
Referência em uma Nova Issue Ver Git Blame Copiar Link Permanente